463 lines
15 KiB
C#
463 lines
15 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Drawing;
|
|
using System.Drawing.Imaging;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using System.Reflection;
|
|
using System.Runtime.InteropServices;
|
|
using System.Windows;
|
|
using System.Windows.Interop;
|
|
using System.Windows.Media;
|
|
using System.Windows.Media.Imaging;
|
|
using RestSharp;
|
|
using MessageBox = System.Windows.MessageBox;
|
|
using PixelFormat = System.Drawing.Imaging.PixelFormat;
|
|
|
|
namespace ChatController.Utilities
|
|
{
|
|
public class Utils
|
|
{
|
|
public static string AuthToken { get; set; }
|
|
|
|
public static string Tenant { get; set; }
|
|
|
|
public static DateTime DefaultDate = new DateTime(1, 1, 1);
|
|
|
|
public static ImageSource AvatarToImageSourceConverter(string pAvatarPath, bool pIsEmployee, bool pIsGroup)
|
|
{
|
|
return CreateImageSourceFromPath(pAvatarPath, pIsGroup, pIsEmployee);
|
|
}
|
|
|
|
public static Bitmap ConvertAvatarToBitmap(string linkToPicture, bool isEmployee, bool isGroup)
|
|
{
|
|
Bitmap bitmap = null;
|
|
|
|
if(!string.IsNullOrWhiteSpace(linkToPicture))
|
|
{
|
|
Debug.WriteLine("Lade Bitmap herunter...");
|
|
|
|
var client = new RestClient(linkToPicture);
|
|
|
|
var request = new RestRequest(Method.GET)
|
|
{
|
|
ResponseWriter = responseStream =>
|
|
{
|
|
try
|
|
{
|
|
bitmap = new Bitmap(responseStream);
|
|
}
|
|
catch(Exception exception)
|
|
{
|
|
|
|
}
|
|
}
|
|
};
|
|
|
|
request.AddHeader(Constants.Token, AuthToken);
|
|
request.AddHeader(Constants.CustomerId, Tenant);
|
|
|
|
client.DownloadData(request);
|
|
}
|
|
|
|
if(bitmap != null)
|
|
{
|
|
return bitmap;
|
|
}
|
|
|
|
var defaultBitmap = (BitmapImage) GetDefaultImageSource(isGroup, isEmployee);
|
|
|
|
using(var outStream = new MemoryStream())
|
|
{
|
|
BitmapEncoder enc = new BmpBitmapEncoder();
|
|
enc.Frames.Add(BitmapFrame.Create(defaultBitmap));
|
|
enc.Save(outStream);
|
|
|
|
return new Bitmap(outStream);
|
|
}
|
|
}
|
|
|
|
public static void DownloadProfilePictureAsync(string avatarPath, bool isEmployee, bool isGroup, Action<ImageSource> callback)
|
|
{
|
|
var url = avatarPath;
|
|
|
|
var client = new RestClient(url);
|
|
var request = new RestRequest
|
|
{
|
|
ResponseWriter = stream =>
|
|
{
|
|
var bitmap = new BitmapImage();
|
|
|
|
var localStream = new MemoryStream();
|
|
|
|
stream.CopyTo(localStream);
|
|
|
|
localStream.Position = 0;
|
|
|
|
bitmap.BeginInit();
|
|
|
|
bitmap.StreamSource = localStream;
|
|
|
|
bitmap.EndInit();
|
|
|
|
bitmap.Freeze();
|
|
|
|
callback?.Invoke(bitmap);
|
|
}
|
|
};
|
|
}
|
|
|
|
private static ImageSource GetDefaultImageSource(bool pIsGroup, bool pIsEmployee)
|
|
{
|
|
var defaultImage = Constants.EmployeeDefaultImagePath;
|
|
|
|
if (pIsGroup)
|
|
{
|
|
defaultImage = pIsEmployee ? Constants.TeamDefaultImagePath : Constants.NormalGroupDefaultImagePath;
|
|
}
|
|
else if (!pIsEmployee)
|
|
{
|
|
defaultImage = Constants.CustomerDefaultImagePath;
|
|
}
|
|
|
|
var resultBitmapImage = new BitmapImage();
|
|
|
|
resultBitmapImage.BeginInit();
|
|
resultBitmapImage.UriSource = new Uri(defaultImage);
|
|
resultBitmapImage.EndInit();
|
|
|
|
return resultBitmapImage;
|
|
}
|
|
|
|
public static ImageSource CreateImageSourceFromPath(string pPathToImageFile, bool pIsGroup = false, bool pIsEmployee = false)
|
|
{
|
|
if (!string.IsNullOrEmpty(pPathToImageFile))
|
|
{
|
|
Debug.WriteLine("Lade Bild herunter...");
|
|
|
|
Bitmap bitmap = null;
|
|
|
|
var client = new RestClient(pPathToImageFile);
|
|
|
|
var request = new RestRequest(Method.GET)
|
|
{
|
|
ResponseWriter = stream =>
|
|
{
|
|
try
|
|
{
|
|
bitmap = new Bitmap(stream);
|
|
}
|
|
catch (ArgumentException)
|
|
{
|
|
bitmap = null;
|
|
}
|
|
}
|
|
};
|
|
|
|
request.AddHeader(Constants.Token, AuthToken);
|
|
request.AddHeader(Constants.CustomerId, Tenant);
|
|
|
|
client.DownloadData(request);
|
|
|
|
if (bitmap != null)
|
|
{
|
|
using (var memoryStream = new MemoryStream())
|
|
{
|
|
bitmap.Save(memoryStream, ImageFormat.Png);
|
|
|
|
memoryStream.Position = 0;
|
|
|
|
var bitmapImage = new BitmapImage();
|
|
|
|
bitmapImage.BeginInit();
|
|
bitmapImage.CacheOption = BitmapCacheOption.OnLoad;
|
|
bitmapImage.StreamSource = memoryStream;
|
|
bitmapImage.EndInit();
|
|
|
|
return bitmapImage;
|
|
}
|
|
}
|
|
}
|
|
|
|
return GetDefaultImageSource(pIsGroup, pIsEmployee);
|
|
}
|
|
|
|
public static string ReadStream(WebResponse response)
|
|
{
|
|
var dataStream = response.GetResponseStream();
|
|
|
|
if (dataStream == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var reader = new StreamReader(dataStream);
|
|
var responseFromServer = reader.ReadToEnd();
|
|
|
|
dataStream.Dispose();
|
|
reader.Dispose();
|
|
|
|
dataStream.Close();
|
|
reader.Close();
|
|
|
|
return responseFromServer;
|
|
}
|
|
|
|
public static string GetAndCreateUserAppDataPath()
|
|
{
|
|
try
|
|
{
|
|
var localAppData = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
|
|
var companyFilePath = Path.Combine(localAppData, Resource.CompanyName);
|
|
|
|
if (!Directory.Exists(companyFilePath))
|
|
{
|
|
Directory.CreateDirectory(companyFilePath);
|
|
}
|
|
|
|
var bewoFilePath = Path.Combine(companyFilePath, Resource.ApplicationFolderName);
|
|
|
|
if (!Directory.Exists(bewoFilePath))
|
|
{
|
|
Directory.CreateDirectory(bewoFilePath);
|
|
}
|
|
|
|
return bewoFilePath;
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
MessageBox.Show("Fehler beim Anlegen des Anwendungsordners. Sie besitzen nicht die erforderlichen Rechte, bitte wenden Sie sich an Ihren Systemadministrator.\n" + exception.Message, "BeWoPlaner", MessageBoxButton.OK, MessageBoxImage.Exclamation);
|
|
}
|
|
|
|
return Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
|
|
}
|
|
|
|
public static string GenerateTempName()
|
|
{
|
|
const int length = 6;
|
|
const string chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
|
|
var random = new Random();
|
|
|
|
var tempName = new string(Enumerable.Repeat(chars, length).Select(s => s[random.Next(s.Length)]).ToArray());
|
|
|
|
return tempName;
|
|
}
|
|
|
|
public static byte[] ImageToByteArray(Image pImage)
|
|
{
|
|
try
|
|
{
|
|
using (var memoryStream = new MemoryStream())
|
|
{
|
|
pImage.Save(memoryStream, ImageFormat.Bmp);
|
|
return memoryStream.ToArray();
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
MessageBox.Show("Fehler: " + e.Message, "Fehler", MessageBoxButton.OK);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static ImageSource GetImageSourceFromIcon(Icon pIcon)
|
|
{
|
|
var bitmap = new Bitmap(pIcon.Width, pIcon.Height);
|
|
|
|
var graphics = Graphics.FromImage(bitmap);
|
|
|
|
graphics.DrawIcon(pIcon, 0, 0);
|
|
|
|
graphics.Dispose();
|
|
|
|
bitmap.Save("icon.ico", ImageFormat.Icon);
|
|
|
|
var imageSource = ImageSourceForBitmap(bitmap);
|
|
|
|
bitmap.Dispose();
|
|
|
|
return imageSource;
|
|
}
|
|
|
|
[DllImport("gdi32.dll", EntryPoint = "DeleteObject")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool DeleteObject([In] IntPtr hObject);
|
|
|
|
public static ImageSource ImageSourceForBitmap(Bitmap bmp)
|
|
{
|
|
var handle = bmp.GetHbitmap();
|
|
|
|
try
|
|
{
|
|
return Imaging.CreateBitmapSourceFromHBitmap(handle, IntPtr.Zero, Int32Rect.Empty, BitmapSizeOptions.FromEmptyOptions());
|
|
}
|
|
finally
|
|
{
|
|
DeleteObject(handle);
|
|
}
|
|
}
|
|
|
|
public static Icon ImageSourceToIcon(ImageSource pImageSource)
|
|
{
|
|
var bitmapSource = (BitmapSource) pImageSource;
|
|
|
|
var width = bitmapSource.PixelWidth;
|
|
var height = bitmapSource.PixelHeight;
|
|
|
|
var newWidth = width;
|
|
var newHeight = height;
|
|
|
|
var x = 0;
|
|
var y = 0;
|
|
|
|
if(width < height)
|
|
{
|
|
newHeight = width;
|
|
y = (height - width) / 2;
|
|
}
|
|
else
|
|
{
|
|
newWidth = height;
|
|
x = (width - height) / 2;
|
|
}
|
|
|
|
var stride = width * ((bitmapSource.Format.BitsPerPixel + 7) / 8);
|
|
var memoryBlockPointer = Marshal.AllocHGlobal(height * stride);
|
|
|
|
bitmapSource.CopyPixels(new Int32Rect(x, y, newWidth, newHeight), memoryBlockPointer, newHeight * stride, stride);
|
|
|
|
var bitmap = new Bitmap(newWidth, newHeight, stride, PixelFormat.Format32bppPArgb, memoryBlockPointer);
|
|
|
|
return Icon.FromHandle(bitmap.GetHicon());
|
|
}
|
|
|
|
public static byte[] ReadFully(Stream pStream)
|
|
{
|
|
using (var memStream = new MemoryStream())
|
|
{
|
|
pStream.CopyTo(memStream);
|
|
return memStream.ToArray();
|
|
}
|
|
}
|
|
|
|
public static RotateFlipType OrientationToFlipType(string orientation)
|
|
{
|
|
switch (int.Parse(orientation))
|
|
{
|
|
case 1:
|
|
return RotateFlipType.RotateNoneFlipNone;
|
|
case 2:
|
|
return RotateFlipType.RotateNoneFlipX;
|
|
case 3:
|
|
return RotateFlipType.Rotate180FlipNone;
|
|
case 4:
|
|
return RotateFlipType.Rotate180FlipX;
|
|
case 5:
|
|
return RotateFlipType.Rotate90FlipX;
|
|
case 6:
|
|
return RotateFlipType.Rotate90FlipNone;
|
|
case 7:
|
|
return RotateFlipType.Rotate270FlipX;
|
|
case 8:
|
|
return RotateFlipType.Rotate270FlipNone;
|
|
default:
|
|
return RotateFlipType.RotateNoneFlipNone;
|
|
}
|
|
}
|
|
|
|
public static List<T> GetVisualChildCollection<T>(object parent) where T : Visual
|
|
{
|
|
var visualCollection = new List<T>();
|
|
GetVisualChildCollection(parent as DependencyObject, visualCollection);
|
|
|
|
return visualCollection;
|
|
}
|
|
|
|
public static void GetVisualChildCollection<T>(DependencyObject parent, ICollection<T> visualCollection) where T : Visual
|
|
{
|
|
var count = VisualTreeHelper.GetChildrenCount(parent);
|
|
for(var i = 0; i < count; i++)
|
|
{
|
|
var child = VisualTreeHelper.GetChild(parent, i);
|
|
|
|
if(child is T item)
|
|
{
|
|
visualCollection.Add(item);
|
|
}
|
|
else
|
|
{
|
|
GetVisualChildCollection(child, visualCollection);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* try
|
|
{
|
|
using (var form = new Form())
|
|
{
|
|
using (var ms = new MemoryStream(e.Result))
|
|
{
|
|
var image = System.Drawing.Image.FromStream(ms);
|
|
|
|
using (var bitmap = new Bitmap(image))
|
|
{
|
|
short orient = 0;
|
|
const int orientationId = 0x0112;
|
|
|
|
if (image.PropertyIdList.Contains(orientationId))
|
|
{
|
|
var item = image.GetPropertyItem(orientationId);
|
|
|
|
orient = BitConverter.ToInt16(item.Value, 0);
|
|
|
|
bitmap.SetPropertyItem(item);
|
|
}
|
|
|
|
var flipType = Utils.OrientationToFlipType(orient.ToString());
|
|
|
|
bitmap.RotateFlip(flipType);
|
|
|
|
form.StartPosition = FormStartPosition.CenterScreen;
|
|
form.ClientSize = bitmap.Size;
|
|
form.FormBorderStyle = FormBorderStyle.Sizable;
|
|
form.Icon = Icon.ExtractAssociatedIcon(Application.ExecutablePath);
|
|
|
|
using (var pictureBox = new PictureBox())
|
|
{
|
|
pictureBox.Dock = DockStyle.Fill;
|
|
pictureBox.Image = bitmap;
|
|
|
|
pictureBox.SizeMode = PictureBoxSizeMode.Zoom;
|
|
|
|
form.Controls.Add(pictureBox);
|
|
|
|
downloadCompletedCallback?.Invoke();
|
|
|
|
form.ShowDialog();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
*/
|
|
|
|
public Bitmap ConvertStreamToBitmap(Stream imageStream)
|
|
{
|
|
try
|
|
{
|
|
var image = Image.FromStream(imageStream);
|
|
|
|
|
|
|
|
return null;
|
|
}
|
|
catch(Exception exception)
|
|
{
|
|
throw exception;
|
|
}
|
|
}
|
|
}
|
|
}
|