/// <summary>
/// Try to open an existng Feedbackthread
/// </summary>
/// <param name="threadToken">thread token for this thread</param>
/// <returns>a populated feedback thread, null if the token is invalid or the thread closed.</returns>
public async Task <IFeedbackThread> OpenFeedbackThreadAsync(string threadToken)
{
if (String.IsNullOrWhiteSpace(threadToken))
{
throw new ArgumentException("Token must not be empty!");
}
FeedbackThread fbThread = null;
try {
fbThread = await FeedbackThread.OpenFeedbackThreadAsync(this, threadToken);
} catch (Exception e) {
HandleInternalUnhandledException(e);
}
return(fbThread);
}
private async Task InitializeAsync()
{
if (FeedbackManager.Instance.IsThreadOpen)
{
if (NetworkInterface.GetIsNetworkAvailable())
{
try
{
FeedbackThread thread = await FeedbackManager.Instance.GetActiveThreadAsync();
if (thread != null)
{
foreach (var msg in (thread.messages))
{
this.Messages.Add(new FeedbackMessageVM(msg));
}
if (FeedbackManager.Instance.FeedbackPageTopTitle.IsEmpty() && !thread.messages.First().subject.IsEmpty())
{
Deployment.Current.Dispatcher.BeginInvoke(() => this.ThreadInfo = thread.messages.First().subject);
}
}
else //thread has been deleted
{
Deployment.Current.Dispatcher.BeginInvoke(() => IsThreadActive = false);
SwitchToMessageForm();
}
}
catch (Exception)
{
Deployment.Current.Dispatcher.BeginInvoke(() =>
{
MessageBox.Show("There has been a connection problem with the server. Please try again later.");
});
}
}
else //no internet connection
{
//TODO warnung kein internet und zurückspringen (navigateback!?)
}
}
else
{
Deployment.Current.Dispatcher.BeginInvoke(() => IsThreadActive = false);
SwitchToMessageForm();
}
SetFormFieldDefaults();
HideOverlay();
}
internal async Task <IEnumerable <FeedbackThreadVM> > LoadFeedbackThreadsAsync()
{
var tokens = platformHelper.GetSettingValue(FeedbackThreadTokensSettingsKey) ?? "";
List <string> tokenList = tokens.Split(FeedbackThreadTokensSeparator).ToList();
List <FeedbackThreadVM> vms = new List <FeedbackThreadVM>();
foreach (string token in tokenList.Where(t => !String.IsNullOrEmpty(t)))
{
var thread = await HockeyClient.Current.AsInternal().OpenFeedbackThreadAsync(token);
if (thread != null)
{
vms.Add(new FeedbackThreadVM(thread));
}
}
if (!vms.Any())
{
vms.Add(new FeedbackThreadVM(FeedbackThread.CreateInstance()));
}
this._openthreadVMs = vms;
return(vms);
}
/// <summary>
/// Send a feedback message to the server
/// (you should not need this if you use the provided feedback page)
/// </summary>
/// <param name="message">message text</param>
/// <param name="email">email address of sender</param>
/// <param name="subject">subject of message</param>
/// <param name="name">name of sender</param>
/// <param name="attachments">The attachments.</param>
/// <returns></returns>
public async Task <IFeedbackMessage> SendFeedback(string message, string email, string subject, string name, IEnumerable <IFeedbackAttachment> attachments)
{
var thread = await this.GetActiveThreadAsync() ?? FeedbackThread.CreateInstance();
foreach (var attachment in attachments)
{
//convert all images to jpg for filesize
var bitimg = new BitmapImage();
bitimg.SetSource(new MemoryStream(attachment.DataBytes));
var wb = new WriteableBitmap(bitimg);
using (var stream = new MemoryStream())
{
wb.SaveJpeg(stream, bitimg.PixelWidth, bitimg.PixelHeight, 0, 70);
stream.Seek(0, System.IO.SeekOrigin.Begin);
var buffer = new byte[stream.Length];
stream.Read(buffer, 0, (int)stream.Length);
attachment.DataBytes = buffer;
}
attachment.FileName = Path.GetFileNameWithoutExtension(attachment.FileName) + ".jpg";
attachment.ContentType = "image/jpeg";
}
IFeedbackMessage msg;
try
{
msg = await thread.PostFeedbackMessageAsync(message, email, subject, name, attachments);
PersistThreadMetaInfos(thread.Token, subject, name, email);
this.activeThread = thread;
}
catch (Exception)
{
this.activeThread = null;
throw;
}
return(msg);
}
/// <summary>
/// Create a feedback thread to post messages on
/// </summary>
/// <returns>an empty IFeedbackThread</returns>
public IFeedbackThread CreateNewFeedbackThread()
{
return(FeedbackThread.CreateInstance());
}
internal async Task RefreshFeedbackThreadVMAsync(FeedbackThreadVM threadVM)
{
if (!threadVM.FeedbackThread.IsNewThread)
{
threadVM.FeedbackThread = (await HockeyClient.Current.AsInternal().OpenFeedbackThreadAsync(threadVM.FeedbackThread.Token)) ?? FeedbackThread.CreateInstance();
}
}
