public async Task <IActionResult> CreateMake(CreateMakeDto newVehicleMake)
{
//simplify message, create ViewModels
var crudAction = CRUDActions.Create;
if (ModelState.IsValid)
{
var createdVehicleMake = (await _vehicleAdministrationService.CreateVehicleMake(newVehicleMake)).Value;
var messageType = FeedbackMessageType.Sucess;
var sucessCreateViewModel = new CreateMakeViewModel()
{
MessageType = messageType,
MessageText = IFeedbackMessage.CRUDMessage(messageType, crudAction, createdVehicleMake.Name)
};
return(RedirectToAction("CreateMake", sucessCreateViewModel));
}
else
{
var messageType = FeedbackMessageType.Failed;
var failedCreateViewModel = new CreateMakeViewModel()
{
MessageType = messageType,
MessageText = FeedbackMessageBase.CRUDMessage(messageType, crudAction, newVehicleMake.Name)
};
return(View("~/Views/Administration/VehicleMake/CreateMake.cshtml", failedCreateViewModel));
}
}
internal void HandleSentMessage(IFeedbackMessage sentMsg)
{
if (!this.CurrentFeedbackThreadVM.Messages.Any(msgVM => msgVM.FeedbackMessage.Id == sentMsg.Id))
{
this.CurrentFeedbackThreadVM.Messages.Add(new FeedbackMessageVM(sentMsg as FeedbackMessage));
}
}
internal void HandleSentMessage(IFeedbackMessage sentMsg)
{
if (!this.Messages.Any(msgVM => msgVM.FeedbackMessage.Id == sentMsg.Id))
{
this.Messages.Add(new FeedbackMessageVM(sentMsg as FeedbackMessage));
}
this.NewMessage = new FeedbackMessageVM() { FeedbackThreadVM = this };
}
public FeedbackMessageReadOnlyVM(IFeedbackMessage msg, FeedbackPageVM parentVM)
{
this.msg = msg;
this.images = this.msg.Attachments.Select(fbImg => new FeedbackImageVM(parentVM)
{
IsEditable = false, FeedbackImage = fbImg
}).ToList();
}
private void SetCommands()
{
Frame rootFrame = (Window.Current.Content as Frame);
CancelCommand = new RelayCommand(() =>
{
rootFrame.GoBack();
});
SendCommand = new RelayCommand(async() =>
{
bool success = true;
if (await ValidateInputAsync())
{
if (NetworkInterface.GetIsNetworkAvailable())
{
this.IsBusy = true;
try
{
IFeedbackMessage sentMessage = await this.SendFeedbackAsync();
await FeedbackManager.Current.ClearMessageCacheAsync();
await AfterSendActionAsync(sentMessage);
}
catch (WebException e)
{
HockeyClient.Current.AsInternal().HandleInternalUnhandledException(e);
success = false;
}
finally
{
this.IsBusy = false;
}
if (!success)
{
await new MessageDialog(LocalizedStrings.LocalizedResources.FeedbackSendError).ShowAsync();
}
}
else
{
await new MessageDialog(LocalizedStrings.LocalizedResources.FeedbackNoInternet).ShowAsync();
}
}
});
AttachImgCommand = new RelayCommand(() =>
{
PickPhoto();
});
EditAttachmentCommand = new RelayCommand((attachVM) =>
{
var vm = attachVM as FeedbackAttachmentVM;
vm.IsNewAttachment = false;
dynamic pars = new DynamicNavigationParameters();
pars.Attachment = vm;
rootFrame.Navigate(this.FeedbackImagePageType, pars);
});
}
internal void HandleSentMessage(IFeedbackMessage sentMsg)
{
if (!this.Messages.Any(msgVM => msgVM.FeedbackMessage.Id == sentMsg.Id))
{
this.Messages.Add(new FeedbackMessageVM(sentMsg as FeedbackMessage));
}
this.NewMessage = new FeedbackMessageVM()
{
FeedbackThreadVM = this
};
}
public async Task SendFeedbackMessage <TOwner>(IFeedbackMessage feedbackMessage) where TOwner : BaseHappyViewModel
{
var viewModel = NavigationService.GetFirstOrDefaultViewModelFromStack <TOwner>();
if (viewModel == null)
{
return;
}
await viewModel.OnFeedback(feedbackMessage);
}
public FeedbackMessageViewModel(IFeedbackMessage message)
{
this._message = message;
if (this._message != null && !String.IsNullOrWhiteSpace(this._message.GravatarHash))
{
Task t = this.LoadGravatar(this._message.GravatarHash);
}
else
{
this.Gravatar = GravatarHelper.DefaultGravatar;
}
}
private async Task AfterSendActionAsync(IFeedbackMessage sentMsg)
{
FeedbackManager.Current.HandleSentMessage(sentMsg);
var frame = (Window.Current.Content as Frame);
frame.Navigate(typeof(FeedbackMainPage));
await CoreWindow.GetForCurrentThread().Dispatcher.RunIdleAsync((o) =>
{
//removeme from backstack
var pageStackEntry = frame.BackStack.LastOrDefault(entry => entry.SourcePageType == typeof(FeedbackFormPage));
if (pageStackEntry != null)
{
frame.BackStack.Remove(pageStackEntry);
}
});
}
public async void Submit()
{
bool wasNewThread = this._fbThreadVM.IsNewThread;
IFeedbackThread fbThread = this._fbThreadVM.FeedbackThread;
IWindowManager wm = IoC.Get <IWindowManager>();
wm.ShowBusyView("Submitting...");
try
{
IFeedbackMessage msg = await fbThread.PostFeedbackMessageAsync(this.Message, this.EMail, this.Subject, this.Username);
HockeyApp.AppLoader.Properties.Settings.Default.LastFeedbackUserName = this.Username;
HockeyApp.AppLoader.Properties.Settings.Default.LastFeedbackUserEMail = this.EMail;
HockeyApp.AppLoader.Properties.Settings.Default.Save();
if (msg != null)
{
if (wasNewThread)
{
FeedbackToken.AddToken(fbThread.Token);
}
this._fbThreadVM.FeedbackMessages.Insert(this._fbThreadVM.FeedbackMessages.Count - 1, new FeedbackMessageViewModel(msg));
this._fbThreadVM.NotifyOfPropertyChange(() => this._fbThreadVM.Subject);
this.NotifyOfPropertyChange(() => this.IsNewThread);
this.Message = "";
}
}
catch (Exception ex)
{
wm.ShowMetroMessageBox("An error ocurred:\n" + ex.Message);
}
finally
{
wm.HideBusyView();
}
}
public FeedbackMessageReadOnlyVM(IFeedbackMessage msg, FeedbackPageVM parentVM)
{
this.msg = msg;
this.images = this.msg.Attachments.Select(fbImg => new FeedbackImageVM(parentVM) { IsEditable = false, FeedbackImage = fbImg }).ToList();
}
protected virtual async Task OnFeedback(IFeedbackMessage feedbackMessage)
{
await Task.Yield();
}
public FeedbackMessageViewModel(IFeedbackMessage message)
{
this._message = message;
if (this._message != null && !String.IsNullOrWhiteSpace(this._message.GravatarHash))
{
Task t = this.LoadGravatar(this._message.GravatarHash);
}
else
{
this.Gravatar = GravatarHelper.DefaultGravatar;
}
}
private void SetCommands()
{
// Window.Current can be null in case of application is suspended.
// issue discussed at https://support.hockeyapp.net/discussions/problems/57803-hockeysdkwinrt-version-223-bug
Frame rootFrame = Window.Current == null ? null : (Window.Current.Content as Frame);
CancelCommand = new RelayCommand(() =>
{
if (rootFrame != null)
{
rootFrame.GoBack();
}
});
SendCommand = new RelayCommand(async() =>
{
bool success = true;
if (await ValidateInputAsync())
{
if (NetworkInterface.GetIsNetworkAvailable())
{
this.IsBusy = true;
try
{
IFeedbackMessage sentMessage = await this.SendFeedbackAsync();
await FeedbackManager.Current.ClearMessageCacheAsync();
await AfterSendActionAsync(sentMessage);
}
catch (WebException e)
{
HockeyClient.Current.AsInternal().HandleInternalUnhandledException(e);
success = false;
}
finally
{
this.IsBusy = false;
}
if (!success)
{
await new MessageDialog(LocalizedStrings.LocalizedResources.FeedbackSendError).ShowAsync();
}
}
else
{
await new MessageDialog(LocalizedStrings.LocalizedResources.FeedbackNoInternet).ShowAsync();
}
}
});
AttachImgCommand = new RelayCommand(() =>
{
PickPhoto();
});
EditAttachmentCommand = new RelayCommand((attachVM) =>
{
var vm = attachVM as FeedbackAttachmentVM;
vm.IsNewAttachment = false;
dynamic pars = new DynamicNavigationParameters();
pars.Attachment = vm;
if (rootFrame != null)
{
rootFrame.Navigate(this.FeedbackImagePageType, pars);
}
});
}
internal void HandleSentMessage(IFeedbackMessage sentMsg)
{
if(!this.CurrentFeedbackThreadVM.Messages.Any(msgVM => msgVM.FeedbackMessage.Id == sentMsg.Id)){
this.CurrentFeedbackThreadVM.Messages.Add(new FeedbackMessageVM(sentMsg as FeedbackMessage));
}
}
/// <summary>
/// Posts the feedback message asynchronous.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="email">The email.</param>
/// <param name="subject">The subject.</param>
/// <param name="name">The name.</param>
/// <param name="attachments">The attachments.</param>
/// <returns></returns>
/// <exception cref="System.Exception">Server error. Server returned status + fbResp.Status</exception>
public async Task <IFeedbackMessage> PostFeedbackMessageAsync(string message, string email = null, string subject = null, string name = null, IEnumerable <IFeedbackAttachment> attachments = null)
{
IHockeyClientInternal client = HockeyClient.Current.AsInternal();
var msg = new FeedbackMessage();
msg.Name = client.UserID;
msg.Text = message;
msg.Email = email;
msg.Name = name;
msg.Subject = subject;
HttpWebRequest request = null;
if (this.IsNewThread)
{
msg.Token = this.Token;
request = WebRequest.CreateHttp(new Uri(client.ApiBaseVersion2 + "apps/" + client.AppIdentifier + "/feedback", UriKind.Absolute));
request.Method = "Post";
}
else
{
request = WebRequest.CreateHttp(new Uri(client.ApiBaseVersion2 + "apps/" + client.AppIdentifier + "/feedback/" + this.Token + "/", UriKind.Absolute));
request.Method = "Put";
}
request.SetHeader(HttpRequestHeader.UserAgent.ToString(), client.UserAgentString);
byte[] dataStream;
if (attachments == null || !attachments.Any())
{
string data = msg.SerializeToWwwForm();
dataStream = Encoding.UTF8.GetBytes(data);
request.ContentType = "application/x-www-form-urlencoded";
request.SetHeader(HttpRequestHeader.ContentEncoding.ToString(), Encoding.UTF8.WebName.ToString());
using (Stream stream = await request.GetRequestStreamAsync())
{
stream.Write(dataStream, 0, dataStream.Length);
stream.Flush();
}
}
else
{
string boundary = "---------------------------" + DateTime.Now.Ticks.ToString("x");
byte[] boundarybytes = System.Text.Encoding.UTF8.GetBytes("\r\n--" + boundary + "\r\n");
request.ContentType = "multipart/form-data; boundary=" + boundary;
using (Stream stream = await request.GetRequestStreamAsync())
{
string formdataTemplate = "Content-Disposition: form-data; name=\"{0}\"\r\n\r\n{1}";
//write form fields
foreach (var keyValue in msg.MessagePartsDict)
{
stream.Write(boundarybytes, 0, boundarybytes.Length);
string formitem = string.Format(formdataTemplate, keyValue.Key, keyValue.Value);
byte[] formitembytes = System.Text.Encoding.UTF8.GetBytes(formitem);
stream.Write(formitembytes, 0, formitembytes.Length);
}
//write images
for (int index = 0; index < attachments.Count(); index++)
{
var attachment = attachments.ElementAt(index);
stream.Write(boundarybytes, 0, boundarybytes.Length);
string headerTemplate = "Content-Disposition: form-data; name=\"{0}\"; filename=\"{1}\"\r\nContent-Type: {2}\r\n\r\n";
string header = string.Format(headerTemplate, "attachment" + index, attachment.FileName, String.IsNullOrEmpty(attachment.ContentType) ? "application/octet-stream" : attachment.ContentType);
byte[] headerbytes = System.Text.Encoding.UTF8.GetBytes(header);
stream.Write(headerbytes, 0, headerbytes.Length);
stream.Write(attachment.DataBytes, 0, attachment.DataBytes.Length);
}
byte[] trailer = System.Text.Encoding.UTF8.GetBytes("\r\n--" + boundary + "--\r\n");
stream.Write(trailer, 0, trailer.Length);
stream.Flush();
}
}
var response = await request.GetResponseAsync();
var fbResp = await TaskEx.Run <FeedbackResponseSingle>(() => FeedbackResponseSingle.FromJson(response.GetResponseStream()));
if (!fbResp.Status.Equals("success"))
{
throw new Exception("Server error. Server returned status " + fbResp.Status);
}
IFeedbackMessage fbNewMessage = fbResp.Feedback.Messages.Last();
if (fbNewMessage != null)
{
this.messages.Add(fbNewMessage as FeedbackMessage);
}
if (this.IsNewThread)
{
this.IsNewThread = false;
}
return(fbNewMessage);
}
private async Task AfterSendActionAsync(IFeedbackMessage sentMsg)
{
FeedbackManager.Current.HandleSentMessage(sentMsg);
var frame = (Window.Current.Content as Frame);
frame.Navigate(typeof(FeedbackMainPage));
await CoreWindow.GetForCurrentThread().Dispatcher.RunIdleAsync((o) =>
{
//removeme from backstack
var pageStackEntry = frame.BackStack.LastOrDefault(entry => entry.SourcePageType == typeof(FeedbackFormPage));
if (pageStackEntry != null) { frame.BackStack.Remove(pageStackEntry); }
});
}
private void SetCommands()
{
AddAttachmentCommand = new RelayCommand(async() =>
{
var picker = new FileOpenPicker();
picker.ViewMode = PickerViewMode.List;
picker.SuggestedStartLocation = PickerLocationId.DocumentsLibrary;
picker.FileTypeFilter.Add("*");
var files = await picker.PickMultipleFilesAsync();
foreach (var file in files)
{
byte[] bytes = null;
using (var stream = await file.OpenReadAsync()) {
IBuffer buffer = WindowsRuntimeBuffer.Create((int)stream.Size);
await stream.ReadAsync(buffer, (uint)stream.Size, InputStreamOptions.None);
bytes = buffer.ToArray();
}
var attach = new FeedbackAttachment(file.Name, bytes, file.ContentType);
this.Attachments.Add(new FeedbackAttachmentVM(attach)
{
FeedbackMessageVM = this
});
}
});
OpenAttachmentCommand = new RelayCommand(async(o) =>
{
await((FeedbackAttachmentVM)o).OpenAttachmentAsync();
});
SendMessageCommand = new RelayCommand(async(o) =>
{
bool success = true;
if (await ValidateInputAsync())
{
if (NetworkInterface.GetIsNetworkAvailable())
{
this.IsBusy = true;
try
{
IFeedbackMessage sentMessage = await this.SendFeedbackAsync();
this.FeedbackThreadVM.HandleSentMessage(sentMessage);
}
catch (Exception e)
{
HockeyClient.Current.AsInternal().HandleInternalUnhandledException(e);
success = false;
}
finally
{
this.IsBusy = false;
}
if (!success)
{
await new MessageDialog(LocalizedStrings.LocalizedResources.FeedbackSendError).ShowAsync();
FeedbackFlyoutVM.ShowFlyout();
}
}
else
{
await new MessageDialog(LocalizedStrings.LocalizedResources.FeedbackNoInternet).ShowAsync();
FeedbackFlyoutVM.ShowFlyout();
}
}
else
{
FeedbackFlyoutVM.ShowFlyout();
}
});
CancelMessageCommand = new RelayCommand((o) => {
this.Message = null;
this.Attachments.Clear();
});
if (!String.IsNullOrWhiteSpace(this.Email))
{
Task t = this.ReLoadGravatar();
}
else
{
this.Gravatar = GravatarHelper.DefaultGravatar;
}
}
public async Task SendFeedbackMessage(IFeedbackMessage feedbackMessage)
{
await NavigationService.GetLastViewModelFromStack().OnFeedback(feedbackMessage);
}
