public async Task <bool> SubmitForm()
{
if (ValidateInput())
{
ShowOverlay();
var msg = new FeedbackMessage()
{
text = this.Message,
email = this.Email,
subject = this.Subject,
name = this.Username
};
var returnedMsg = await FeedbackManager.Instance.SendFeedback(msg, this.Username, this.Email);
if (returnedMsg != null)
{
this.Messages.Add(new FeedbackMessageVM(returnedMsg));
this.ClearForm();
SwitchToMessageList();
return(true);
}
else
{
HideOverlay();
MessageBox.Show("An error occcured. Please try again.");
}
}
return(false);
}
// GET: Home
public ActionResult Index()
{
ViewBag.Title = "WGC";
FeedbackMessage feedbackMessage = new FeedbackMessage();
return(View(feedbackMessage));
}
public ActionResult PopupForm(FeedbackMessage message)
{
message.Comment = Server.HtmlDecode(message.Comment);
ViewData["message"] = message;
return(View());
}
public HttpResponseMessage Post(FeedbackMessage message)
{
var mail = new MailMessage();
mail.From = new MailAddress("*****@*****.**",
$"Код пользователя {CurrentUser.Id} код клиента {CurrentUser.Client.Id} [{CurrentUser.Client.Name}]");
if (message.IsBilling)
{
mail.To.Add(new MailAddress(Config.BillingMail));
}
else if (message.IsOffice)
{
mail.To.Add(new MailAddress(Config.OfficeMail));
}
else
{
mail.To.Add(new MailAddress(Config.SupportMail));
}
mail.Subject = message.Subject;
mail.Body = message.Body;
if (message.Attachments != null && message.Attachments.Length > 0)
{
mail.Attachments.Add(new Attachment(new MemoryStream(message.Attachments), "Вложения.zip"));
}
var client = new SmtpClient();
client.Send(mail);
return(new HttpResponseMessage(HttpStatusCode.OK));
}
public Task SendMessageAsync(FeedbackMessage feedbackMessage)
{
var message = FormatMessage(feedbackMessage);
var emails = messageEmailService.GetAll().Select(i => i.Email);
return(sender.SendEmailAsync(emails, FEEDBACK_SUBJECT, message));
}
/// <summary>
/// Map InputModel to QueueModel.
/// </summary>
/// <param name="feedback">Feedback input model to map.</param>
/// <returns>FeedbackQueueItem</returns>
public static FeedbackQueueItem MapToQueueItem(this FeedbackMessage feedback) => new FeedbackQueueItem
{
Email = feedback.Email,
Tel = feedback.Tel,
FullName = feedback.FullName,
Message = feedback.Message
};
/// <summary>
/// Gets the hash code
/// </summary>
/// <returns>Hash code</returns>
public override int GetHashCode()
{
unchecked // Overflow is fine, just wrap
{
var hashCode = 41;
// Suitable nullity checks etc, of course :)
if (Phoneid != null)
{
hashCode = hashCode * 59 + Phoneid.GetHashCode();
}
if (FeedbackType != null)
{
hashCode = hashCode * 59 + FeedbackType.GetHashCode();
}
if (FeedbackValue != null)
{
hashCode = hashCode * 59 + FeedbackValue.GetHashCode();
}
if (FeedbackMessage != null)
{
hashCode = hashCode * 59 + FeedbackMessage.GetHashCode();
}
if (FeedbackLat != null)
{
hashCode = hashCode * 59 + FeedbackLat.GetHashCode();
}
if (FeedbackLon != null)
{
hashCode = hashCode * 59 + FeedbackLon.GetHashCode();
}
return(hashCode);
}
}
public void TestMessageAppendedEvent()
{
InitializeHttpContext();
var store = new FeedbackMessageStore();
var feedbackMessage = FeedbackMessage.Info("test raise appended event.");
int countRaiseEvent = 0;
EventHandler <MessageAppendedEventArgs> handler = (sender, args) =>
{
Assert.AreEqual(store, sender);
Assert.AreEqual(feedbackMessage, args.Message);
countRaiseEvent++;
};
// register
store.OnMessageAppeded += handler;
store.AddMessage(feedbackMessage);
Assert.AreEqual(1, countRaiseEvent);
// unregister
store.OnMessageAppeded -= handler;
store.AddMessage(FeedbackMessage.Warn("test unregister event"));
Assert.AreEqual(1, countRaiseEvent);
}
public void TestAddMessages()
{
InitializeHttpContext();
var store = new FeedbackMessageStore();
List <FeedbackMessage> messages = new List <FeedbackMessage>();
var info = FeedbackMessage.Info("Test info message.");
var warn = FeedbackMessage.Warn("Test warn message.");
messages.Add(info);
messages.Add(warn);
store.AddMessages(messages);
IList <FeedbackMessage> infoMessages = store.GetFeedbackMessages(FeedbackMessageLevel.INFO);
Assert.AreEqual(1, infoMessages.Count);
Assert.IsTrue(infoMessages.Contains(info));
IList <FeedbackMessage> successMessages = store.GetFeedbackMessages(FeedbackMessageLevel.SUCCESS);
Assert.AreEqual(0, successMessages.Count);
IList <FeedbackMessage> warnMessages = store.GetFeedbackMessages(FeedbackMessageLevel.WARN);
Assert.AreEqual(1, warnMessages.Count);
Assert.IsTrue(warnMessages.Contains(warn));
IList <FeedbackMessage> errorMessages = store.GetFeedbackMessages(FeedbackMessageLevel.ERROR);
Assert.AreEqual(0, errorMessages.Count);
}
// Update is called once per frame
void CheckForActionItem()
{
if (Input.GetButtonDown("X360_A01"))
{
Collider[] colliders = Physics.OverlapSphere(transform.position, radius);
foreach (Collider other in colliders)
{
if (other.gameObject.tag == "Disguise" && disguised == false)
{
FeedbackMessage.getInstance().AddMessage("Voce pegou um disfarce", 5);
if (!disguised)
{
disguised = true;
}
}
else if (other.gameObject.tag == "Info")
{
Config.getInstance().UpdateCollectedInfos();
FeedbackMessage.getInstance().AddMessage("Voce pegou uma informação", 5);
Destroy(other.gameObject);
}
}
}
}
void Awake()
{
if (_instance == null)
{
_instance = this;
}
}
public void ParseAndResolveTypes()
{
GoalMessage.ParseAndResolveTypes();
GoalActionMessage.ParseAndResolveTypes();
ResultMessage.ParseAndResolveTypes();
ResultActionMessage.ParseAndResolveTypes();
FeedbackMessage.ParseAndResolveTypes();
FeedbackActionMessage.ParseAndResolveTypes();
}
private byte[] GetByteArrayForFeedbackMessage(FeedbackMessage feedbackMessage)
{
using (MemoryStream memoryStream = new MemoryStream())
using (BinaryWriter binaryWriter = new BinaryWriter(memoryStream))
{
feedbackMessage.Serialize(binaryWriter);
return(((MemoryStream)binaryWriter.BaseStream).ToArray());
}
}
public void TriggerFailPanel(GameStats stats)
{
FeedbackMessage newMessage = feedbackGenerator.GenerateMessage(stats);
feedbackText.text = newMessage.message;
feedbackIcon.sprite = newMessage.failIcon;
failPanel.SetActive(true);
failPanel.GetComponent <Animator>().SetBool("Open", true);
}
public static FeedbackMessageReturnDTO ToFeedbackMessageReturnDTO(this FeedbackMessage message)
{
return(new FeedbackMessageReturnDTO
{
User = message.Author.UserToUserReturnDTO(),
Id = message.Id,
Text = message.Text,
Created = message.Created
});
}
public ActionResult Message(FeedbackMessage feedbackMessage)
{
if (ModelState.IsValid)
{
//its valid, update your database or do soemthing useful here
return(RedirectToAction("Success"));
}
//its not valid reload the page and let data annotations show the error
return(View("Index", feedbackMessage));
}
public static void AppendValidationErrorsToStore(EditContext editContext)
{
var messageStore = FeedbackMessageStore.Current;
foreach (var validationMessage in editContext.GetValidationMessages())
{
var feedbackMessage = FeedbackMessage.Error(validationMessage);
messageStore.Add(feedbackMessage);
}
}
public void TestMarkRendered()
{
var message = FeedbackMessage.Info("test message");
Assert.IsFalse(message.IsRendered);
message.MarkRendered();
Assert.IsTrue(message.IsRendered);
}
public static FeedbackMessage getInstance()
{
if (_instance == null)
{
_instance = new FeedbackMessage();
}
else
{
}
return(_instance);
}
public void TestSetFactory()
{
InitializeHttpContext();
Func <FeedbackMessage, string> func = msg => msg.ToString();
var builder = new FeedbackMessageScriptBuilder(func);
var message = FeedbackMessage.Info("Info message");
Assert.IsNotNull(builder.ScriptFactory);
Assert.AreEqual(func.Invoke(message), builder.ScriptFactory.Convert(message));
}
protected string FormatMessage(FeedbackMessage message)
{
StringBuilder builder = new StringBuilder();
builder.AppendFormat("Name: {0}\n", message.Name);
builder.AppendFormat("Email: {0}\n", message.Email);
builder.AppendFormat("Phone: {0}\n", message.Phone);
builder.AppendFormat("Company: {0}\n\n", message.Company);
builder.AppendFormat("Message: {0}\n", message.Message);
return(builder.ToString());
}
public void TestGetOnDomReadyScripts()
{
InitializeHttpContext();
var builder = new FeedbackMessageScriptBuilder(msg => msg.ToString());
FeedbackMessageStore.Current.AddMessage(FeedbackMessage.Info("Info message"));
var str = builder.GetDomReadyScript();
Assert.IsTrue(str.Contains(builder.GetScripts()));
}
private void SendCryptedFeedbackMessage(FeedbackMessage feedbackMessage, byte[] feebdackBuffer, RemotePlayContext remotePlayContext, Socket udpClient)
{
feedbackMessage.TagPos = (uint)remotePlayContext.LocalKeyPosition;
byte[] feedbackMessageData = GetByteArrayForFeedbackMessage(feedbackMessage);
int macOffset = GetMacOffset(6); // crypto position
CryptoService.AddGmacToBuffer(remotePlayContext.LocalGmacInfo, feedbackMessage.TagPos, feedbackMessageData, macOffset);
feebdackBuffer = CryptoService.EncryptGmacMessage(remotePlayContext.LocalGmacInfo, feedbackMessage.TagPos, feebdackBuffer);
remotePlayContext.LocalKeyPosition += 16; //controlMessage.UnParsedPayload.Length < 16 ? 16 : controlMessage.UnParsedPayload.Length;
SendData(udpClient, ByteUtil.ConcatenateArrays(feedbackMessageData, feebdackBuffer));
}
public BaseViewModel(T data, string message, string registerdBy)
{
this.Data = data;
FeedbackMessage fmessage = new FeedbackMessage(message, eFeedbackType.SUCCESS, Guid.NewGuid(), registerdBy);
List <FeedbackMessage> messages = new List <FeedbackMessage>();
messages.Add(fmessage);
this.IsSuccess = true;
this.Messages = messages;
}
protected void btnSendFeedback_Click(object sender, EventArgs e)
{
try
{
var htmlTemplate = FillEmailTempalte();
FeedbackMessage.SendEmail(htmlTemplate, tbEmail.Text);
mvSendFeedback.ActiveViewIndex = mvSendFeedback.ActiveViewIndex + 1;
}
catch (Exception ex)
{
Log.Error("Send FeedBack: ", ex, this);
}
}
public void TestContains()
{
var store = new FeedbackMessageStore();
var message = FeedbackMessage.Info("Test");
store.AddMessage(message);
store.AddMessage(FeedbackMessage.Info("Test2"));
Assert.AreEqual(2, store.Count);
Assert.IsTrue(store.Contains(message));
Assert.IsFalse(store.Contains(FeedbackMessage.Warn("Test")));
}
public void TestClear()
{
var store = new FeedbackMessageStore();
var message = FeedbackMessage.Info("Test");
store.AddMessage(message);
store.AddMessage(FeedbackMessage.Info("Test2"));
Assert.AreEqual(2, store.Count);
store.Clear();
Assert.AreEqual(0, store.Count);
}
private void HandleFeedbackData(Socket udpSocket, RemotePlayContext remotePlayContext)
{
Thread heartBeatThread = new Thread(() =>
{
try
{
do
{
FeedbackMessage feedbackMessage = new FeedbackMessage(_feedbackSequenceNumber, 0, 0, 0);
byte[] buf = new byte[25];
buf[0x0] = 0xa0; // TODO
buf[0x1] = 0xff; // TODO
buf[0x2] = 0x7f; // TODO
buf[0x3] = 0xff; // TODO
buf[0x4] = 0x7f; // TODO
buf[0x5] = 0xff; // TODO
buf[0x6] = 0x7f; // TODO
buf[0x7] = 0xff; // TODO
buf[0x8] = 0x7f; // TODO
buf[0x9] = 0x99; // TODO
buf[0xa] = 0x99; // TODO
buf[0xb] = 0xff; // TODO
buf[0xc] = 0x7f; // TODO
buf[0xd] = 0xfe; // TODO
buf[0xe] = 0xf7; // TODO
buf[0xf] = 0xef; // TODO
buf[0x10] = 0x1f; // TODO
buf[0x11] = 0; // TODO
buf[0x12] = 0; // TODO
buf[0x13] = 0; // TODO
buf[0x14] = 0; // TODO
buf[0x15] = 0; // TODO
buf[0x16] = 0; // TODO
buf[0x17] = 0; // TODO
buf[0x18] = 0; // TODO
SendCryptedFeedbackMessage(feedbackMessage, buf, remotePlayContext, udpSocket);
++_feedbackSequenceNumber;
Thread.Sleep(200);
} while (true);
}
catch (Exception)
{
// ignore
}
});
heartBeatThread.IsBackground = true;
heartBeatThread.Start();
}
public static bool Send(Client client, int MsgCategory, int MsgNum)
{
var message = new FeedbackMessage
{
Identity = client.Character.Identity,
Unknown = 0x01,
Unknown1 = 0x00000000,
CategoryId = MsgCategory,
MessageId = MsgNum
};
client.SendCompressed(message);
return(true);
}
public void TestStringConverter()
{
var converter = new FeedbackMessageStringConverter();
Assert.IsNotNull(converter.StringFactory);
var message = FeedbackMessage.Info("Convert test");
Assert.AreEqual("Convert test", converter.Convert(message));
converter.StringFactory = msg => "prefix-" + msg.ToString();
Assert.AreEqual("prefix-Convert test", converter.Convert(message));
}
