/// <summary>
/// Uses a <see cref="IDbCommand" /> to retrieve a scalar value using the given <paramref name="commandText" />.
/// </summary>
/// <typeparam name="TResult">The type of the expected result.</typeparam>
/// <param name="commandText">The command text to execute.</param>
/// <param name="connection">The connection to use for the query.</param>
/// <param name="commandTimeout">The command timeout in seconds.</param>
/// <returns>The result or the default value of <typeparamref name="TResult" /> if an error occurs.</returns>
/// <exception cref="ArgumentException">
/// Is thrown if the <paramref name="commandText" /> or <paramref name="connection" /> are invalid.
/// </exception>
public static async Task <TResult> GetScalarResultAsync <TResult>(string commandText, IDbConnection connection, int commandTimeout = 30)
{
CheckUtil.ThrowIfNull(() => connection);
CheckUtil.ThrowIfNullOrEmpty(() => commandText);
try
{
using (var command = connection.CreateCommand())
{
command.CommandTimeout = commandTimeout;
var commandToUse = command as DbCommand;
CheckUtil.ThrowIfNull(() => commandToUse);
// ReSharper disable once PossibleNullReferenceException
commandToUse.CommandText = commandText;
var result = await commandToUse.ExecuteScalarAsync();
if (result == null)
{
return(default(TResult));
}
return((TResult)result);
}
}
catch (Exception ex)
{
ExceptionCallback?.Invoke(ex);
return(default(TResult));
}
}
/// <summary>
/// Retrieves a DateTime for the given <paramref name="columnName" />.
/// </summary>
/// <param name="reader">The reader to extend.</param>
/// <param name="columnName">The name of the column in the reader result.</param>
/// <returns>The value.</returns>
public static DateTime?GetDateTimeValue(this IDataReader reader, string columnName)
{
CheckUtil.ThrowIfNull(() => reader);
CheckUtil.ThrowIfNullOrEmpty(() => columnName);
var offset = GetColumnOffset(reader, columnName);
return(reader.IsDBNull(offset) ? default(DateTime?) : reader.GetDateTime(offset));
}
/// <summary>
/// Retrieves a value from a reader.
/// </summary>
/// <typeparam name="TResult">The expected result.</typeparam>
/// <param name="reader">The reader to extend.</param>
/// <param name="columnName">The name of the column in the reader result.</param>
/// <returns>The value of the column.</returns>
public static TResult GetValue <TResult>(this IDataReader reader, string columnName)
{
CheckUtil.ThrowIfNull(() => reader);
CheckUtil.ThrowIfNullOrEmpty(() => columnName);
var offset = GetColumnOffset(reader, columnName);
var value = reader.GetValue(offset);
return((TResult)value);
}
/// <summary>
/// Retrieves the offset of a column with the specified <paramref name="columnName" />.
/// </summary>
/// <param name="reader">The reader to extend.</param>
/// <param name="columnName">The name of the column in the reader result.</param>
/// <returns>The index of the column.</returns>
public static int GetColumnOffset(this IDataReader reader, string columnName)
{
CheckUtil.ThrowIfNull(() => reader);
CheckUtil.ThrowIfNullOrEmpty(() => columnName);
if (reader.IsClosed)
{
throw new InvalidOperationException("Reader is closed");
}
return(reader.GetOrdinal(columnName));
}
/// <summary>
/// Iterates through a list of T and retrieves the index of the element matching the <paramref name="compareFunc" /> inside
/// the enumerable.
/// </summary>
/// <typeparam name="T">The type of an element inside the <paramref name="enumerable" />.</typeparam>
/// <param name="enumerable">The enumerable to extend.</param>
/// <param name="compareFunc">The element to find.</param>
/// <returns>The offset of the element or -1 if the element wasn't found in the enumerable.</returns>
public static int GetIndexOf <T>(this IEnumerable <T> enumerable, Func <T, bool> compareFunc)
{
var enumerableToUse = enumerable as T[] ?? enumerable.ToArray();
CheckUtil.ThrowIfNull(() => enumerableToUse);
for (var i = 0; i < enumerableToUse.Count(); i++)
{
if (compareFunc(enumerableToUse[i]))
{
return(i);
}
}
return(-1);
}
/// <summary>
/// Gets the value for a given <paramref name="secureValue"/>.
/// </summary>
/// <param name="secureValue">The secured text.</param>
/// <returns>The readable text.</returns>
public static string ToUnsecureString(this SecureString secureValue)
{
CheckUtil.ThrowIfNull(() => secureValue);
var unmanagedString = IntPtr.Zero;
try
{
unmanagedString = Marshal.SecureStringToGlobalAllocUnicode(secureValue);
return(Marshal.PtrToStringUni(unmanagedString));
}
finally
{
Marshal.ZeroFreeGlobalAllocUnicode(unmanagedString);
}
}
/// <summary>
/// Retrieves the result asynchronously.
/// </summary>
/// <param name="ctx">The entity context to use.</param>
/// <param name="cancellationToken">A token for cancelling the opertation.</param>
/// <param name="query">An optional query on the entities to use (if <c>null</c>, GetValidEntities is used).</param>
/// <param name="filter">An optional filter expression.</param>
public async Task GenerateAsync(TContext ctx, CancellationToken cancellationToken, IQueryable <TEntity> query = null, Expression <Func <TEntity, bool> > filter = null)
{
if (query == null)
{
CheckUtil.ThrowIfNull(() => Util);
query = Util.GetValidEntities(ctx, filter);
}
CompleteItemsCount = await query.CountAsync(cancellationToken);
if (Request.OrderByExpressions != null && Request.OrderByExpressions.Any())
{
// we habe to cycle through each desired order-expression and build up our query-
var firstItem = true;
foreach (var orderBy in Request.OrderByExpressions)
{
if (firstItem)
{
// this is the first item so that ThenBy can not be applied
query = orderBy.OrderDirection == OrderByDirections.Ascending ? query.OrderBy(orderBy.PropertyName) : query.OrderByDescending(orderBy.PropertyName);
firstItem = false;
}
else
{
// this is not the first item so that each order has to be done using Then*
var ordered = query as IOrderedQueryable <TEntity>;
if (ordered == null)
{
throw new InvalidOperationException("Could not retrieve ordered elements from previous iteration.");
}
query = orderBy.OrderDirection == OrderByDirections.Ascending ? ordered.ThenBy(orderBy.PropertyName) : ordered.ThenByDescending(orderBy.PropertyName);
}
}
}
else
{
// order by Id if no other order is defined
query = query.OrderBy(e => e.Id);
}
// generate and return the result
var itemsToSkip = Request.EntriesToSkip ?? (Request.PageToDeliver - 1) * Request.ItemsPerPage;
Items = await query.Skip(itemsToSkip).Take(Request.ItemsPerPage).ToListAsync(cancellationToken);
}
/// <summary>
/// Uploads a single image to an Azure blob.
/// </summary>
/// <param name="container">The storage container to use.</param>
/// <param name="image">The image to upload,</param>
/// <param name="remoteFileName">The name the file should have in the storage container.</param>
/// <param name="remoteFolder">A folder name to use or create in the storage container.</param>
/// <returns><c>true</c> if the upload succeeds otherwise <c>false</c>.</returns>
public static async Task <bool> UploadImageAsync(CloudBlobContainer container, Image image, string remoteFileName, string remoteFolder = null)
{
var name = remoteFileName;
CheckUtil.ThrowIfNullOrEmpty(() => name);
CheckUtil.ThrowIfNull(() => image);
if (!remoteFolder.IsNullOrEmpty())
{
// ReSharper disable once AssignNullToNotNullAttribute
remoteFileName = Path.Combine(remoteFolder, remoteFileName);
}
var newBlob = container.GetBlockBlobReference(remoteFileName);
newBlob.Properties.ContentType = image.GetMimeContentType();
var bytes = image.GetByteArrayFromImage(image.RawFormat);
await newBlob.UploadFromByteArrayAsync(bytes, 0, bytes.Length);
return(true);
}
/// <summary>
/// Sends a RFC conform email using default .NET classes.
/// </summary>
/// <param name="messageToSend">The pre-configured <see cref="MailMessage" /> to send.</param>
/// <param name="settings">A structure containing the settings for the server.</param>
/// <returns><c>True</c> if the mail was sent, otherwise <c>false</c>.</returns>
public static async Task <bool> SendMailAsync(MailMessage messageToSend, MailServerSettings settings)
{
CheckUtil.ThrowIfNull(() => messageToSend);
try
{
// Send the mail and use credentials if given.
using (var client = new SmtpClient(settings.ServerAddress, settings.Port))
{
if (settings.UseDefaultCredentials)
{
client.Credentials = CredentialCache.DefaultNetworkCredentials;
}
else
{
if (!string.IsNullOrEmpty(settings.Username) && !string.IsNullOrEmpty(settings.Password))
{
client.Credentials = new NetworkCredential(settings.Username, settings.Password, settings.Domain ?? string.Empty);
}
}
await client.SendMailAsync(messageToSend);
}
return(true);
}
catch (Exception ex)
{
var error = string.Format(
CultureInfo.InvariantCulture,
"Cannot send e-mail from '{0}' to '{1}' with subject '{2}': {3}",
messageToSend.From,
messageToSend.To,
messageToSend.Subject,
ex);
var file = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonDocuments), "mail.error");
using (var writer = File.AppendText(file))
{
writer.Write(error);
writer.Close();
}
throw new InvalidOperationException(error, ex);
}
}
/// <summary>
/// Searches for an app setting with the provided <paramref name="key"/> from the calling configuration and returns its value converted to <typeparamref name="T"/>.
/// </summary>
/// <remarks>
/// This method will throw exceptions on any failure.
/// </remarks>
/// <param name="key">The unique key out of the app-settings.</param>
/// <typeparam name="T">Target type which has to be an <see cref="IConvertible"/>.</typeparam>
/// <returns>The value of type <typeparamref name="T"/> if one could be obtained.</returns>
public static T Get <T>(string key) where T : IConvertible
{
CheckUtil.ThrowIfNull(() => key);
var value = AppSettings[key];
if (value == null)
{
var error = string.Format(CultureInfo.InvariantCulture, "Cannot find key '{0}' in config-file.", key);
throw new KeyNotFoundException(error);
}
try
{
var result = (T)Convert.ChangeType(value, typeof(T), CultureInfo.CurrentCulture);
return(result);
}
catch (Exception ex)
{
var error = string.Format(CultureInfo.InvariantCulture, "Cannot convert '{0}' to type '{1}': {2}", value, typeof(T), ex);
throw new InvalidOperationException(error, ex);
}
}
/// <summary>
/// Retrieves a reader for a given <paramref name="commandText" /> on the <paramref name="connection" />.
/// </summary>
/// <param name="commandText">The command text to execute.</param>
/// <param name="connection">The connection to use for the query.</param>
/// <param name="behavior">The command beavior for the reader.</param>
/// <param name="commandTimeout">The command timeout in seconds.</param>
/// <returns>The reader or <c>null</c> if an error occurs.</returns>
/// <exception cref="ArgumentException">
/// Is thrown if the <paramref name="commandText" /> or <paramref name="connection" /> are invalid.
/// </exception>
public static async Task <IDataReader> GetReaderAsync(string commandText, IDbConnection connection, CommandBehavior behavior = CommandBehavior.CloseConnection, int commandTimeout = 30)
{
CheckUtil.ThrowIfNull(() => connection);
CheckUtil.ThrowIfNullOrEmpty(() => commandText);
try
{
using (var command = connection.CreateCommand())
{
command.CommandTimeout = commandTimeout;
var commandToUse = command as DbCommand;
CheckUtil.ThrowIfNull(() => commandToUse);
// ReSharper disable once PossibleNullReferenceException
commandToUse.CommandText = commandText;
return(await commandToUse.ExecuteReaderAsync(behavior));
}
}
catch (Exception ex)
{
ExceptionCallback?.Invoke(ex);
return(null);
}
}
/// <summary>
/// Encrypts a given <paramref name="plainText"/> symetrically using <see cref="RijndaelManaged"/>.
/// </summary>
/// <param name="plainText">The plain text.</param>
/// <param name="key">The secret key.</param>
/// <param name="iv">The initialization vector of the alogrithm.</param>
/// <returns>The encrypted text coded in Base64.</returns>
public static string EncryptText(string plainText, byte[] key, byte[] iv)
{
CheckUtil.ThrowIfNullOrEmpty(() => plainText);
CheckUtil.ThrowIfNull(() => key);
CheckUtil.ThrowIfNull(() => iv);
string encrypted;
using (var rijndael = new RijndaelManaged())
{
rijndael.Key = key;
rijndael.IV = iv;
var encryptor = rijndael.CreateEncryptor(rijndael.Key, rijndael.IV);
var memStream = new MemoryStream();
var cryptStream = new CryptoStream(memStream, encryptor, CryptoStreamMode.Write);
using (var writer = new StreamWriter(cryptStream))
{
writer.Write(plainText);
}
encrypted = Convert.ToBase64String(memStream.ToArray());
}
return(encrypted);
}
/// <summary>
/// Decrypts a given <paramref name="cipherText"/> symetrically using <see cref="RijndaelManaged"/>.
/// </summary>
/// <param name="cipherText">The encrypted Base64-encoded text.</param>
/// <param name="key">The secret key.</param>
/// <param name="iv">The initialization vector of the alogrithm.</param>
/// <returns>The decrypted text.</returns>
public static string DecryptText(string cipherText, byte[] key, byte[] iv)
{
CheckUtil.ThrowIfNullOrEmpty(() => cipherText);
CheckUtil.ThrowIfNull(() => key);
CheckUtil.ThrowIfNull(() => iv);
string plaintext;
using (var rijndael = new RijndaelManaged())
{
rijndael.Key = key;
rijndael.IV = iv;
var decryptor = rijndael.CreateDecryptor(rijndael.Key, rijndael.IV);
var cipherTextBytes = Convert.FromBase64String(cipherText);
var memStream = new MemoryStream(cipherTextBytes);
var cryptStream = new CryptoStream(memStream, decryptor, CryptoStreamMode.Read);
using (var reader = new StreamReader(cryptStream))
{
plaintext = reader.ReadToEnd();
}
}
return(plaintext);
}
/// <summary>
/// Executes a given <paramref name="commandText" /> on the <paramref name="connection" />.
/// </summary>
/// <param name="commandText">The command text to execute.</param>
/// <param name="connection">The connection to use for the query.</param>
/// <param name="commandTimeout">The command timeout in seconds.</param>
/// <returns>The amount of affected rows or -1 if an error occured.</returns>
/// <exception cref="ArgumentException">
/// Is thrown if the <paramref name="commandText" /> or <paramref name="connection" /> are invalid.
/// </exception>
public static async Task <int> ExecuteCommandAsync(string commandText, IDbConnection connection, int commandTimeout = 30)
{
CheckUtil.ThrowIfNull(() => connection);
CheckUtil.ThrowIfNullOrEmpty(() => commandText);
try
{
using (var command = connection.CreateCommand())
{
command.CommandTimeout = commandTimeout;
var commandToUse = command as DbCommand;
CheckUtil.ThrowIfNull(() => commandToUse);
// ReSharper disable once PossibleNullReferenceException
commandToUse.CommandText = commandText;
return(await commandToUse.ExecuteNonQueryAsync());
}
}
catch (Exception ex)
{
ExceptionCallback?.Invoke(ex);
return(-1);
}
}
/// <summary>
/// Starts handling of one or many alarms.
/// </summary>
/// <param name="alarmTimes">The times when to start alarms.</param>
/// <param name="onlyOnces">Indicates whether the clock should run forever.</param>
public void Start(IEnumerable <TimeSpan> alarmTimes, bool onlyOnces = true)
{
if (IsRunning)
{
throw new InvalidOperationException("Stop a running alarm clock first.");
}
CheckUtil.ThrowIfNull(() => alarmTimes);
if (!alarmTimes.Any())
{
throw new ArgumentException("No times specified.");
}
if (AlarmOccured == null)
{
throw new InvalidOperationException("No listener on AlarmOccured event. Alarm is useless.");
}
IsRunning = true;
_alarms = 0;
_alarmTimes = alarmTimes.ToList();
_onlyOnce = onlyOnces;
AlarmClockStarted?.Invoke(this, EventArgs.Empty);
StartNextTimer();
}
/// <summary>
/// Iterates through a list of T and retrieves the index of the <paramref name="element" /> inside the enumerable.
/// </summary>
/// <typeparam name="T">The type of an element inside the <paramref name="enumerable" />.</typeparam>
/// <param name="enumerable">The enumerable to extend.</param>
/// <param name="element">The element to find.</param>
/// <returns>The offset of the element or -1 if the element wasn't found in the enumerable.</returns>
public static int GetIndexOf <T>(this IEnumerable <T> enumerable, T element)
where T : IComparable
{
CheckUtil.ThrowIfNull(() => enumerable);
return(enumerable.GetIndexOf(t => t.Equals(element)));
}
/// <summary>
/// Retrieves the <see cref="DbSet" /> from the given <paramref name="ctx" /> which holds all items of the current
/// <typeparamref name="TEntity" />.
/// </summary>
/// <param name="ctx">The EF context to use.</param>
/// <returns>The entity set from the EF context.</returns>
public DbSet <TEntity> GetEntitiesSet(TContext ctx)
{
CheckUtil.ThrowIfNull(() => ctx);
return(ctx.Set <TEntity>());
}
