private void GenerateNewMessage()
{
for (int i = 0; i < _random.Next(5); i++)
{
Message newMessage;
if (_random.NextDouble() < PropabilityOfImageMessage)
{
newMessage = new ImageMessage()
{
Channel = GetRandomChannel(),
From = GetRandomUser(),
Text = GetRandomMessage(),
Sent = DateTime.Now.AddSeconds(_random.NextDouble()),
ImageUrl = $"https://picsum.photos/id/{_random.Next(500)}/200"
};
}
else
{
newMessage = new Message()
{
Channel = GetRandomChannel(),
From = GetRandomUser(),
Text = GetRandomMessage(),
Sent = DateTime.Now.AddSeconds(_random.NextDouble())
};
}
_messagesToBeSent.Add(newMessage);
}
}
public static void Run(
[QueueTrigger("image-to-process")] ImageMessage myQueueId, TraceWriter log,
[DocumentDB("metadata", "analyzed-images", Id = "{Id}")] ProcessedImage originalEntry,
[Queue("ocr-draw")] out ImageMessage contentMessage)
{
if (originalEntry == null)
{
log.Info("Nothing to process: TextRecognizer");
contentMessage = null;
return;
}
log.Info($"C# Queue trigger function processed: {myQueueId.Id}");
try
{
originalEntry.OcrData = ImageService.RecognizeText(originalEntry.OriginalImageUrl);
contentMessage = new ImageMessage(originalEntry.Id);
}
catch (ClientException e)
{
log.Info($"Unable to process: {e.Message}");
contentMessage = null;
}
}
void LoadImageMessageThread(object data)
{
string message = System.Text.Encoding.UTF8.GetString((byte[])data);
ImageMessage imageMessage = JsonUtility.FromJson <ImageMessage>(message);
currImages.Add(imageMessage);
}
public void ShouldConvertStringUrl()
{
var message = new ImageMessage("https://foo.url", "https://foo.previewUrl");
Assert.AreEqual("https://foo.url/", message.Url.ToString());
Assert.AreEqual("https://foo.previewurl/", message.PreviewUrl.ToString());
}
private async Task GenerateNewMessageAsync(IUnitOfWork unitOfWork)
{
int nrOfMessagesToCreate = _random.Next(100);
for (int i = 0; i < nrOfMessagesToCreate; i++)
{
Message newMessage;
if (_random.NextDouble() < _propabilityOfImageMessage)
{
newMessage = new ImageMessage()
{
ChannelId = GetRandomChannel().Id,
FromId = GetRandomUser().Id,
Text = GetRandomMessage(),
Sent = DateTime.Now.AddSeconds(_random.NextDouble()),
ImageUrl = $"https://picsum.photos/id/{_random.Next(500)}/200"
};
}
else
{
newMessage = new Message()
{
ChannelId = GetRandomChannel().Id,
FromId = GetRandomUser().Id,
Text = GetRandomMessage(),
Sent = DateTime.Now.AddSeconds(_random.NextDouble())
};
}
await unitOfWork.MessageRepository.AddAsync(newMessage);
}
Console.WriteLine($"[{DateTime.Now:dd.MM.yyyy hh:mm:ss}] Messages Created: {nrOfMessagesToCreate,3}");
}
public void ProcessMessage(MsgReply rply, IChatMessage[] chain)
{
StringBuilder str = new StringBuilder();
List <string> pic = new List <string>();
foreach (IChatMessage msg in chain)
{
switch (msg.Type)
{
case PlainMessage.MsgType:
PlainMessage pmsg = (PlainMessage)msg;
str.Append(pmsg.Message);
break;
case ImageMessage.MsgType:
ImageMessage imsg = (ImageMessage)msg;
pic.Add(imsg.Url);
break;
default:
break;
}
}
PrivateMessage(rply, str.ToString(), pic.ToArray());
}
/// <summary>
/// Upload the received data to blob and returns the address
/// </summary>
private async Task HandleMediaAsync(EventMessageType type, string replyToken, string messageId, string blobDirectoryName, string blobName)
{
var stream = await messagingClient.GetContentStreamAsync(messageId);
var ext = GetFileExtension(stream.ContentHeaders.ContentType.MediaType);
var uri = await blobStorage.UploadFromStreamAsync(stream, blobDirectoryName, blobName + ext);
ISendMessage reply = null;
switch (type)
{
case EventMessageType.Audio:
reply = new AudioMessage(uri.ToString(), 100);
break;
case EventMessageType.Image:
reply = new ImageMessage(uri.ToString(), uri.ToString());
break;
case EventMessageType.Video:
reply = new VideoMessage(uri.ToString(), "https://linetestbot123.blob.core.windows.net/linebotcontainer/User_U21d2cd1795be4caa1a32d069fe7b323f/7015056697532.jpeg");
break;
case EventMessageType.File:
reply = new TextMessage(uri.ToString());
break;
}
await messagingClient.ReplyMessageAsync(replyToken, new List <ISendMessage> {
reply
});
//await messagingClient.ReplyMessageAsync(replyToken, uri.ToString());
}
public void OnRewardedWithEngageBtn_Clicked()
{
var engagement = new Engagement("showRewardOrImage");
engagement.AddParam("clickCount", ++clickCount);
DDNA.Instance.RequestEngagement(engagement, response => {
// Since ads must be specifically disabled, try to build image message
// first. If that fails, then see if the ad had been disabled.
var imageMessage = ImageMessage.Create(response);
var rewardedAd = RewardedAd.Create(response);
if (imageMessage != null)
{
Debug.Log("Got an image message.");
imageMessage.OnDidReceiveResources += () => {
imageMessage.Show();
};
imageMessage.FetchResources();
}
else if (rewardedAd != null)
{
rewardedAd.Show();
}
else
{
Debug.Log("Engage didn't return an image and prevented the ad from showing.");
}
}, exception => {
Debug.Log("Engage encountered an error: " + exception.Message);
});
}
private void myImageMessageHandler(ImageMessage imageMessage)
{
// Add a handler for the 'dismiss' action.
imageMessage.OnDismiss += (ImageMessage.EventArgs obj) => {
Debug.Log("Image Message dismissed by " + obj.ID);
// NB : parameters not processed if player dismisses action
};
// Add a handler for the 'action' action.
imageMessage.OnAction += (ImageMessage.EventArgs obj) => {
Debug.Log("Image Message actioned by " + obj.ID + " with command " + obj.ActionValue);
// Process parameters on image message if player triggers image message action
if (imageMessage.Parameters != null)
{
myGameParameterHandler(imageMessage.Parameters);
}
};
imageMessage.OnDidReceiveResources += () =>
{
Debug.Log("Received Image Message Assets");
};
// the image message is already cached and prepared so it will show instantly
imageMessage.Show();
}
public async Task <IActionResult> UploadFiles(FileDescriptionShort fileDescriptionShort)
{
if (ModelState.IsValid)
{
foreach (var file in fileDescriptionShort.File)
{
if (file.Length > 0)
{
using (var memoryStream = new MemoryStream())
{
await file.CopyToAsync(memoryStream);
var imageMessage = new ImageMessage
{
ImageHeaders = "data:" + file.ContentType + ";base64,",
ImageBinary = memoryStream.ToArray()
};
await _hubContext.Clients.All.SendAsync("ImageMessage", imageMessage);
}
}
}
}
return(Redirect("/FileClient/Index"));
}
public async Task Add(
[Summary("The message to add. If including a URL to an image, it needs to be the last thing in the message.")] string message)
{
await Configuration.Modify <RandomlyConfig>(_config.ConfigKey, a =>
{
var newMessage = new ImageMessage()
{
Message = message,
Image = null
};
if (Context.Message.Attachments.Any())
{
newMessage.Image = Context.Message.Attachments.FirstOrDefault()?.Url;
}
else if (message.Contains("http"))
{
var startIndex = message.IndexOf("http");
var url = message.Substring(startIndex, message.Length - startIndex).Trim();
var msg = message.Substring(0, startIndex).Trim();
newMessage.Image = url;
newMessage.Message = msg;
}
var tags = Context.Message.Tags;
}, Context.Guild.Id).ConfigureAwait(false);
await Context.User.SendMessageAsync($"\"{message}\" added.").ConfigureAwait(false);
}
public async Task <HttpResponseMessage> SendImageMessage(ImageMessage imageMessage)
{
ResponseBase <IList <MMPro.MM.UploadMsgImgResponse> > response = new ResponseBase <IList <MMPro.MM.UploadMsgImgResponse> >();
try
{
IList <MMPro.MM.UploadMsgImgResponse> list = new List <MMPro.MM.UploadMsgImgResponse>();
byte[] buffer = await FileStorageHelper.DownloadToBufferAsync(imageMessage.ObjectName);
foreach (var item in imageMessage.ToWxIds)
{
var result = wechat.SendImageMessage(imageMessage.WxId, item, buffer);
list.Add(result);
}
response.Data = list;
}
catch (ExpiredException ex)
{
response.Success = false;
response.Code = "401";
response.Message = ex.Message;
}
catch (Exception ex)
{
response.Success = false;
response.Code = "500";
response.Message = ex.Message;
}
return(await response.ToHttpResponseAsync());
}
public async Task <IActionResult> UploadFiles(IFormFile file)
{
IFormFile fileFromRequest = null;
if (file == null)
{
fileFromRequest = HttpContext?.Request?.Form?.Files?[0] ?? null;
}
if (file == null && fileFromRequest == null)
{
return(BadRequest());
}
var user = await this.authManager.GetUserAsync(HttpContext.User);
using (var memoryStream = new MemoryStream())
{
await fileFromRequest.CopyToAsync(memoryStream);
var imageMessage = new ImageMessage
{
ImageHeaders = "data:" + fileFromRequest.ContentType + ";base64,",
ImageBinary = memoryStream.ToArray()
};
if (hubContext.Clients != null) //TODO - Remove this ugly hack when FileUploadControllerTests is mocking the SignalR ChatHub.cs
{
await hubContext.Clients?.All?.SendAsync("imageMessage", user.UserName, imageMessage);
}
}
return(Ok());
}
internal async Task HandleImageAsync(ControllerParameter parameter)
{
var data = parameter.Packet.Data;
var imageHash = data["imageHash"].As <string>();
var message = new ImageMessage(data["messageId"].As <string>())
{
ImageHash = imageHash, Status = MessageStatus.Pending
};
try
{
if (await ResponseAsync(parameter, message) == false)
{
return;
}
if (!Cache.Exists(imageHash, out var fullpath))
{
fullpath = await Cache.RequestAsync(imageHash, parameter.SenderProfile.GetTcpEndPoint(), cancellation.Token);
}
await UpdateUIAsync(() =>
{
message.ImagePath = fullpath;
message.Status = MessageStatus.Success;
});
}
catch (Exception)
{
await UpdateUIAsync(() => message.Status = MessageStatus.Aborted);
throw;
}
}
public void ShouldSetTheProperties()
{
var message = new ImageMessage(new Uri("https://foo.url"), new Uri("https://foo.previewUrl"));
Assert.AreEqual("https://foo.url/", message.Url.ToString());
Assert.AreEqual("https://foo.previewurl/", message.PreviewUrl.ToString());
}
async Task <bool> ITempMessage.TempMessage(MiraiHttpSession session, ITempMessageEventArgs e)
{
if (BotInfo.BannedUser.Contains(e.Sender.Id))
{
return(false);
}
if (BotInfo.DebugMode)
{
if (BotInfo.DebugReplyAdminOnly)
{
if (!BotInfo.AdminQQ.Contains(e.Sender.Id))
{
return(false);
}
}
}
if (e.Chain.Length > 1) //普通消息
{
switch (e.Chain[1].Type)
{
case "Plain":
PlainMessageHandler.HandleFriendMesage(session, e.Chain, e.Sender.Id);
break;
case "Image":
for (int i = 1; i < e.Chain.Length; i++)
{
ImageMessage imgMsg = e.Chain[i] as ImageMessage;
await SearchPictureHandler.SearchPicture(imgMsg, picStream => session.UploadPictureAsync(UploadTarget.Group, picStream), msg => session.SendTempMessageAsync(e.Sender.Id, e.Sender.Group.Id, msg));
}
break;
}
}
return(false);
}
public void Constructor_SerializedCorrectly()
{
ImageMessage message = new ImageMessage("https://foo.url", "https://foo.previewUrl");
string serialized = JsonConvert.SerializeObject(message);
Assert.AreEqual(@"{""type"":""image"",""originalContentUrl"":""https://foo.url"",""previewImageUrl"":""https://foo.previewUrl""}", serialized);
}
private void SendImage(ImageMessage message)
{
if (message.AccessToken == null)
{
message.AccessToken = Config.AccessToken;
}
_SendImage(message);
}
private void _SendImage(ImageMessage message)
{
string sendUrl = ApiUrl.GetSendCustomUrl(message.AccessToken);
string result = HttpHelper.PostJson(sendUrl, JsonConvert.SerializeObject(message));
ResultModel.CreateInstance(result).HasException();
}
private void AppendImageMessage(ImageMessage msg, StringBuilder sb)
{
sb.AppendLine(FormatSenderAndTime(msg) + @"\\");
sb.AppendLine(@"\begin{center}");
sb.AppendLine(@"\includegraphics[height=0.1\textheight]{" + Path.Combine(ImageDir, msg.Filename) + @"}\\");
sb.AppendFormat(@"\small{{\textit{{{0}}}}}", Encode(msg.Subscription));
sb.AppendLine(@"\end{center}");
}
private async Task SendPictureAsync(MiraiHttpSession session, string path) // 发图
{
// 你也可以使用另一个重载 UploadPictureAsync(PictureTarget, Stream)
// mirai-api-http 在v1.7.0以下时将使用本地的HttpListener做图片中转
ImageMessage msg = await session.UploadPictureAsync(PictureTarget.Group, path);
IMessageBase[] chain = new IMessageBase[] { msg }; // 数组里边可以加上更多的 IMessageBase, 以此达到例如图文并发的情况
await session.SendGroupMessageAsync(0, chain); // 自己填群号, 一般由 IGroupMessageEventArgs 提供
}
public void ShouldThrowExceptionWhenValueIsMoreThan1000Chars()
{
var message = new ImageMessage();
ExceptionAssert.Throws <InvalidOperationException>("The url cannot be longer than 1000 characters.", () =>
{
message.Url = new Uri("https://foo.bar/" + new string('x', 985));
});
}
public void OnImageReceived(ImageMessage currImage)
{
if (TargetController.Instance.imageTransferError)
{
return;
}
StartCoroutine(LoadImageRoutine(currImage));
}
private void processImageMessage(ImageMessage msg)
{
string textToShow = $"{msg.MessageTime.ToString()} - {msg.Source.Name}: Image Received";
_clientData.Outputter.DisplayText(textToShow);
string imgPath = _clientData.Outputter.SaveAnImage(msg.Image);
_clientData.Outputter.DisplayAnImage(imgPath);
}
public void Url_MoreThan1000Chars_ThrowsException()
{
ImageMessage message = new ImageMessage();
ExceptionAssert.Throws <InvalidOperationException>("The url cannot be longer than 1000 characters.", () =>
{
message.Url = new Uri("https://foo.bar/" + new string('x', 985));
});
}
public void PreviewUrl_Null_ThrowsException()
{
ImageMessage message = new ImageMessage();
ExceptionAssert.Throws <InvalidOperationException>("The url cannot be null.", () =>
{
message.PreviewUrl = null;
});
}
public void PreviewUrl_NotHttps_ThrowsException()
{
ImageMessage message = new ImageMessage();
ExceptionAssert.Throws <InvalidOperationException>("The url should use the https scheme.", () =>
{
message.PreviewUrl = new Uri("http://foo.bar");
});
}
public void ShouldThrowExceptionWhenValueIsNotHttps()
{
var message = new ImageMessage();
ExceptionAssert.Throws <InvalidOperationException>("The url should use the https scheme.", () =>
{
message.Url = new Uri("http://foo.bar");
});
}
void OnImageMessageReceivedFromPeerHandler(int id, string peerId, ImageMessage imageMessage)
{
string msg = string.Format("received image message with id:{0} peer:{1} mediaID:{2}", id, peerId, imageMessage.GetMediaId());
Debug.Log(msg);
messageDisplay.AddTextToDisplay(msg, Message.MessageType.Info);
RcvImageMessage = imageMessage;
DownloadImageButton.interactable = true;
}
public void ShouldThrowExceptionWhenValueIsNull()
{
var message = new ImageMessage();
ExceptionAssert.Throws <InvalidOperationException>("The url cannot be null.", () =>
{
message.Url = null;
});
}
private void OnSelectPicturButtonClicked(object sender, RoutedEventArgs e)
{
OpenFileDialog dlg = new OpenFileDialog
{
Filter = "Images|*.jpg;*.gif;*.png"
};
dlg.FileOk += (s, a) =>
{
Action begin = () =>
{
var msg = new ImageMessage { Filename = Path.GetFileName(dlg.FileName) };
byte[] imageData;
using (FileStream fs = File.Open(dlg.FileName, FileMode.Open))
{
imageData = new byte[fs.Length];
fs.Position = 0;
fs.Read(imageData, 0, imageData.Length);
}
msg.ImageData = imageData;
try
{
_bus.Publish<ImageMessage>(msg);
}
catch
{
MessageBox.Show(string.Format("The image file '{0}' wasn't transmitted to the service bus. The image probably exceeds the maximum size.", dlg.FileName));
}
};
begin.BeginInvoke(
new AsyncCallback((ia) =>
{
begin.EndInvoke(ia);
}), null);
};
dlg.ShowDialog();
}
internal void sendVideoAsync(ImageMessage msg, AsyncCallback callback, Object state)
{
msg.sendMeAsync(_videoTcp.GetStream(), callback, state);
}
internal void sendVideo(ImageMessage msg)
{
msg.sendMe(_videoTcp.GetStream());
}
private void SaveImageToBlobStorage(ImageMessage msg)
{
Log(string.Format("Saving {0} to blob storage", msg.Filename));
var url = string.Empty;
using (var ms = new MemoryStream())
{
ms.Write(msg.ImageData, 0, msg.ImageData.Length);
ms.Position = 0;
CloudBlob blob = this._container.GetBlobReference(msg.Filename);
blob.UploadFromStream(ms);
url = blob.Uri.AbsoluteUri;
ms.Close();
}
Log(string.Format("Saved {0} to blob storage", msg.Filename));
PublishBlobStoredImageUrl(url);
}
