/// <summary>
/// Immediately save data.
/// </summary>
/// <returns></returns>
public async Task ForceSave()
{
using (await _saveLock.LockAsync())
{
var chat = await _botClient.GetChatAsync(_saveResChatId);
var prevPinnedMessage = chat.PinnedMessage;
SaveStorageStateToFile();
Message savedMsg = null;
using (var readStream = File.OpenRead(_storageFilePath))
{
savedMsg = await _botClient.SendDocumentAsync(
_saveResChatId,
new InputOnlineFile(readStream, FileResName),
caption : FileResName
);
}
await _botClient.PinChatMessageAsync(_saveResChatId, savedMsg.MessageId);
if (_deletePreviousMessages)
{
await _botClient.DeleteMessageAsync(_saveResChatId, prevPinnedMessage.MessageId);
}
}
}
private static void Main(string[] args)
{
bool removeDirectory;
string temporaryDirectory = GetTemporaryDirectory(out removeDirectory);
Console.WriteLine("Working directory: {0}", temporaryDirectory);
try
{
IPackageRepository sourceRepository = PackageRepositoryFactory.Default.CreateRepository("https://www.nuget.org/api/v2/");
PackageManager packageManager = new PackageManager(sourceRepository, temporaryDirectory);
packageManager.PackageInstalled += HandlePackageInstalled;
packageManager.InstallPackage("Microsoft.Bcl.Immutable", SemanticVersion.Parse("1.0.34"));
packageManager.InstallPackage("System.Collections.Immutable", SemanticVersion.Parse("1.1.33-beta"));
using (PEReader referenceAssembly = new PEReader(File.OpenRead(Path.Combine(temporaryDirectory, "Microsoft.Bcl.Immutable.1.0.34", "lib", "portable-net45+win8+wp8+wpa81", "System.Collections.Immutable.dll"))))
{
using (PEReader newAssembly = new PEReader(File.OpenRead(Path.Combine(temporaryDirectory, "System.Collections.Immutable.1.1.33-beta", "lib", "portable-net45+win8+wp8+wpa81", "System.Collections.Immutable.dll"))))
{
Analyzer analyzer = new Analyzer(referenceAssembly, newAssembly, null);
analyzer.Run();
}
}
}
finally
{
if (removeDirectory)
{
Directory.Delete(temporaryDirectory, true);
}
}
}
public override async Task <JobResult> Execute(DBContext db, SqlService sql, AppSettings settings)
{
var file = await db.UploadedFiles.AsQueryable().Where(f => f.Id == FileId).FirstOrDefaultAsync();
using (var client = new FtpClient("storage.bunnycdn.com"))
{
client.Credentials = new NetworkCredential(settings.BunnyCDN_User, settings.BunnyCDN_Password);
await client.ConnectAsync();
using (var stream = File.OpenRead(Path.Combine("public", "files", file.MungedName)))
{
await client.UploadAsync(stream, file.MungedName, progress : new Progress(file.MungedName));
}
await db.Jobs.InsertOneAsync(new Job
{
Priority = Job.JobPriority.High,
Payload = new IndexJob
{
Archive = new Archive
{
Name = file.MungedName,
Size = file.Size,
Hash = file.Hash,
State = new HTTPDownloader.State
{
Url = file.Uri
}
}
}
});
}
return(JobResult.Success());
}
public async Task SendResult(object sender, CaptureResponseEventArgs e)
{
if (e == null)
{
Logger.Warn("result is null, ignoring");
return;
}
var message = e.Request.RequestContext as Message;
if (message == null)
{
Logger.Error("Returned RequestContext is not a valid Telegram UserRequest object");
return;
}
if (e.Attachments != null)
{
foreach (var filePath in e.Attachments)
{
using (var fs = File.OpenRead(filePath))
{
var trial = 0;
var succeed = false;
var fileName = Path.GetFileName(filePath);
while (!succeed && trial < MaxUploadRetries)
{
try
{
Logger.Debug($"(retry {trial}/{MaxUploadRetries}) Uploading file \"{fileName}\"");
var inputOnlineFile = new InputOnlineFile(fs, fileName);
await _bot.SendDocumentAsync(message.Chat, inputOnlineFile,
replyToMessageId : message.MessageId);
succeed = true;
}
catch (ApiRequestException)
{
Logger.Warn("Telegram API timeout");
trial += 1;
}
}
if (!succeed)
{
Logger.Error("Unable to upload file \"{fileName}\"");
e.StatusText += "Unable to upload file \"{fileName}\".\n";
}
}
}
}
Logger.Debug("Sending session information");
await _bot.SendTextMessageAsync(
message.Chat,
$"<pre>{e}</pre>",
replyToMessageId : message.MessageId,
parseMode : ParseMode.Html
);
}
public static bool OpenWrapEnabled(string filePath)
{
if (!SysFile.Exists(filePath))
{
return(false);
}
var xmlDoc = new XmlDocument();
var namespaceManager = new XmlNamespaceManager(xmlDoc.NameTable);
namespaceManager.AddNamespace("msbuild", MSBUILD_NS);
using (var projectFileStream = SysFile.OpenRead(filePath))
xmlDoc.Load(projectFileStream);
var isOpenWrap = (from node in xmlDoc.SelectNodes(@"//msbuild:Import", namespaceManager).OfType <XmlElement>()
let attr = node.GetAttribute("Project")
where attr != null && Regex.IsMatch(attr, @"OpenWrap\..*\.targets")
select node).Any();
var isDisabled =
(
from node in xmlDoc.SelectNodes(@"//msbuild:OpenWrap-EnableVisualStudioIntegration", namespaceManager).OfType <XmlElement>()
let value = node.Value
where value != null && value.EqualsNoCase("false")
select node
).Any();
return(isOpenWrap && !isDisabled);
}
private string ProcessFile(ContentPropertyData editorValue, ContentItemFile file, string currentPath, Guid cuid, Guid puid)
{
// process the file
// no file, invalid file, reject change
if (UploadFileTypeValidator.ValidateFileExtension(file.FileName) == false)
{
return(null);
}
// get the filepath
// in case we are using the old path scheme, try to re-use numbers (bah...)
var filepath = _mediaFileSystem.GetMediaPath(file.FileName, currentPath, cuid, puid); // fs-relative path
using (var filestream = File.OpenRead(file.TempFilePath))
{
_mediaFileSystem.AddFile(filepath, filestream, true); // must overwrite!
var ext = _mediaFileSystem.GetExtension(filepath);
if (_mediaFileSystem.IsImageFile(ext))
{
var preValues = editorValue.PreValues.FormatAsDictionary();
var sizes = preValues.Any() ? preValues.First().Value.Value : string.Empty;
using (var image = Image.FromStream(filestream))
_mediaFileSystem.GenerateThumbnails(image, filepath, sizes);
}
// all related properties (auto-fill) are managed by ImageCropperPropertyEditor
// when the content is saved (through event handlers)
}
return(filepath);
}
public async Task Should_Set_Webhook_With_SelfSigned_Cert()
{
await _fixture.SendTestCaseNotificationAsync(FactTitles.ShouldSetWebhookWithCertificate);
const string url = "https://www.telegram.org/";
const int maxConnections = 5;
using (var stream = File.OpenRead(Constants.FileNames.Certificate.PublicKey))
{
await BotClient.SetWebhookAsync(
url : url,
certificate : stream,
maxConnections : maxConnections,
allowedUpdates : new UpdateType[0]
);
}
WebhookInfo info = await BotClient.GetWebhookInfoAsync();
Assert.Equal(url, info.Url);
Assert.True(info.HasCustomCertificate);
Assert.Equal(maxConnections, info.MaxConnections);
Assert.Null(info.AllowedUpdates);
await BotClient.DeleteWebhookAsync();
}
private static async Task UploadToSharePoint(string path, string siteUrl, string requestUrl, string fieldName, string fieldValue)
{
using (var handler = new HttpClientHandler {
UseDefaultCredentials = true
})
{
using (var client = new HttpClient(handler))
{
client.DefaultRequestHeaders.Add("Accept", "application/json; odata=verbose");
var contextInfo = await client.PostAsync(siteUrl + "_api/contextinfo", null);
var contextResponseContent = await contextInfo.Content.ReadAsStringAsync().ConfigureAwait(true);
JToken contextObj = JsonConvert.DeserializeObject <dynamic>(contextResponseContent);
var digestValue = contextObj["d"]["GetContextWebInformation"]["FormDigestValue"];
client.DefaultRequestHeaders.Add("X-RequestDigest", (string)digestValue);
var streamContent = new StreamContent(File.OpenRead(path));
var byteArrayContent = new ByteArrayContent(streamContent.ReadAsByteArrayAsync().Result);
byteArrayContent.Headers.ContentType = MediaTypeHeaderValue.Parse("multipart/form-data");
HttpResponseMessage uploadResponse = await client.PostAsync(requestUrl, byteArrayContent).ConfigureAwait(true);
var uploadResponseContent = await uploadResponse.Content.ReadAsStringAsync().ConfigureAwait(true);
if (uploadResponse.IsSuccessStatusCode)
{
JToken spFileObj = JsonConvert.DeserializeObject <dynamic>(uploadResponseContent);
ClientContext context = new ClientContext(Regex.Replace(requestUrl, "/_api.*", "", RegexOptions.IgnoreCase));
var web = context.Web;
var file = web.GetFileByServerRelativeUrl((string)spFileObj.SelectToken("d.ServerRelativeUrl"));
var fileItem = file.ListItemAllFields;
context.Load(web);
context.Load(file);
context.Load(fileItem);
context.ExecuteQuery();
var wasCheckedOut = file.CheckOutType != CheckOutType.None;
if (!wasCheckedOut)
{
file.CheckOut();
}
fileItem.ParseAndSetFieldValue(fieldName, fieldValue);
fileItem.Update();
if (!wasCheckedOut)
{
file.CheckIn(string.Empty, CheckinType.OverwriteCheckIn);
}
context.ExecuteQuery();
}
}
}
}
protected FileStreamResult Pdf(string fileName,
string fileDownloadName)
{
var resumeFile = IOFile.OpenRead(fileName);
return(File(resumeFile,
"application/pdf",
fileDownloadName));
}
public async Task <IActionResult> GetProfilePicture()
{
var userImageDestination = string.Format(
$"{UserImageDestination}_optimized.jpg",
this.User.Identity.Name);
await using var file = FileSystem.OpenRead(userImageDestination);
return(this.File(file, ImageContentType));
}
public void Run()
{
// Gets MediaPickerActivity's private members
_imageAvailableHandler._mediaPickerActivity.Accept(_imageAvailableHandler);
_imageAvailableHandler._createMediaFile();
StoreImage();
Task.Run(NotifyImageStored);
#region Local functions
void StoreImage() // Stores captured image to specified location
{
ByteBuffer buffer = _image.GetPlanes()[0].Buffer;
byte[] bytes = new byte[buffer.Remaining()];
buffer.Get(bytes);
using (var fileOutputStream =
new FileOutputStream(_imageAvailableHandler._convertUriToPath(_imageAvailableHandler._newMediaFileUri), true))
{
try
{
fileOutputStream.Write(bytes);
}
catch (IOException e)
{
e.PrintStackTrace();
}
finally
{
_image.Close();
}
}
}
async Task NotifyImageStored()
{
MediaPickedEventArgs args = GetMediaFile();
await Task.Delay(1).ConfigureAwait(false);
_imageAvailableHandler._onMediaPicked(args);
}
MediaPickedEventArgs GetMediaFile()
{
string albumPath = _imageAvailableHandler._newMediaFileUri.ToString(),
resultPath = _imageAvailableHandler._convertUriToPath(_imageAvailableHandler._newMediaFileUri);
if (resultPath != null && File.Exists(resultPath))
{
var mediaFile = new MediaFile(resultPath, () => File.OpenRead(resultPath), albumPath);
return(new MediaPickedEventArgs(default, false, mediaFile));
public override async Task <JobResult> Execute(SqlService sql, AppSettings settings)
{
int retries = 0;
TOP:
var file = await sql.UploadedFileById(FileId);
if (settings.BunnyCDN_User == "TEST" && settings.BunnyCDN_Password == "TEST")
{
return(JobResult.Success());
}
using (var client = new FtpClient("storage.bunnycdn.com"))
{
client.Credentials = new NetworkCredential(settings.BunnyCDN_User, settings.BunnyCDN_Password);
await client.ConnectAsync();
using (var stream = File.OpenRead(Path.Combine("public", "files", file.MungedName)))
{
try
{
await client.UploadAsync(stream, file.MungedName, progress : new Progress((RelativePath)file.MungedName));
}
catch (Exception ex)
{
if (retries > 10)
{
throw;
}
Utils.Log(ex.ToString());
Utils.Log("Retrying FTP Upload");
retries++;
goto TOP;
}
}
await sql.EnqueueJob(new Job
{
Priority = Job.JobPriority.High,
Payload = new IndexJob
{
Archive = new Archive(new HTTPDownloader.State(file.Uri))
{
Name = file.MungedName,
Size = file.Size,
Hash = file.Hash,
}
}
});
}
return(JobResult.Success());
}
public static ReadOnlyCollection <Message> AnalyzeAssemblies(string referenceAssemblyFile, string newAssemblyFile)
{
using (PEReader referenceAssembly = new PEReader(File.OpenRead(referenceAssemblyFile)))
{
using (PEReader newAssembly = new PEReader(File.OpenRead(newAssemblyFile)))
{
TestMessageLogger logger = new TestMessageLogger();
Analyzer analyzer = new Analyzer(referenceAssembly, newAssembly, logger);
analyzer.Run();
return(logger.RawMessages);
}
}
}
private static void Main(string[] args)
{
string assemblyPath = args[0];
using (PEReader peReader = new PEReader(File.OpenRead(assemblyPath), PEStreamOptions.PrefetchMetadata))
{
ISet <AssemblyName> exposedDependencies = new HashSet <AssemblyName>(new AssemblyNameEqualityComparer());
MetadataReader metadataReader = peReader.GetMetadataReader();
foreach (var type in metadataReader.TypeDefinitions)
{
TypeDefinition typeDefinition = metadataReader.GetTypeDefinition(type);
if (!IsExposedType(metadataReader, typeDefinition))
{
continue;
}
Console.WriteLine("Exposed type: {0}", GetFullName(metadataReader, typeDefinition));
CheckType(metadataReader, typeDefinition, exposedDependencies);
foreach (var eventDefinitionHandle in typeDefinition.GetEvents())
{
CheckEvent(metadataReader, metadataReader.GetEventDefinition(eventDefinitionHandle), exposedDependencies);
}
foreach (var methodDefinitionHandle in typeDefinition.GetMethods())
{
CheckMethod(metadataReader, metadataReader.GetMethodDefinition(methodDefinitionHandle), exposedDependencies);
}
foreach (var propertyDefinitionHandle in typeDefinition.GetProperties())
{
CheckProperty(metadataReader, metadataReader.GetPropertyDefinition(propertyDefinitionHandle), exposedDependencies);
}
foreach (var fieldDefinitionHandle in typeDefinition.GetFields())
{
CheckField(metadataReader, metadataReader.GetFieldDefinition(fieldDefinitionHandle), exposedDependencies);
}
}
Console.WriteLine();
Console.WriteLine("Exposed Dependencies ({0}):", Path.GetFileName(args[0]));
foreach (AssemblyName dependency in exposedDependencies.OrderBy(i => i.FullName, StringComparer.OrdinalIgnoreCase))
{
Console.WriteLine(" {0}", dependency.FullName);
}
}
}
/// <summary>
/// Проверка изображения на допустимость к загрузке
/// </summary>
/// <param name="imagePath"></param>
public void CheckDownloadingImage(string imagePath)
{
//Проверка загружаемого изображения
SysImage image;
using (var imgStream = File.OpenRead(imagePath))
{
image = SysImage.FromStream(imgStream);
}
if (image.Height < 700 || image.Width < 1270 || image.Height > image.Width)
{
throw new ImageException("Принимаются изображения с размерами не меньше чем 1270 пикселей в ширину и 700 пикселей в высоту.");
}
}
public void CanSyncDTest()
{
this.Execute("/d", () =>
{
var hashAlgorithm = new QuickXorHash();
Assert.True(File.Exists("/d".ToAbsolutePath(_driveHive.LocalDrivePath)), "File does not exist.");
Assert.True(File.Exists("/d".ToAbsolutePath(_driveHive.RemoteDrivePath)), "File does not exist.");
using (var stream = File.OpenRead("/d".ToAbsolutePath(_driveHive.LocalDrivePath)))
{
Assert.True(Convert.ToBase64String(hashAlgorithm.ComputeHash(stream)) == Utils.DriveItemPool["/d1"].QuickXorHash());
}
});
}
/** Load full path name .st file relative to root by prefix */
public virtual CompiledTemplate LoadTemplateFile(string prefix, string unqualifiedFileName)
{
if (Path.IsPathRooted(unqualifiedFileName))
{
throw new ArgumentException();
}
if (Verbose)
{
Console.WriteLine("loadTemplateFile({0}) in groupdir from {1} prefix={2}", unqualifiedFileName, root, prefix);
}
string templateName = Path.ChangeExtension(unqualifiedFileName, null);
Uri f;
try
{
f = new Uri(root.LocalPath + prefix + unqualifiedFileName);
}
catch (UriFormatException me)
{
ErrorManager.RuntimeError(null, ErrorType.INVALID_TEMPLATE_NAME, me, Path.Combine(root.LocalPath, unqualifiedFileName));
return(null);
}
ANTLRReaderStream fs = null;
try
{
fs = new ANTLRReaderStream(new StreamReader(File.OpenRead(f.LocalPath), Encoding));
fs.name = unqualifiedFileName;
}
catch (IOException)
{
if (Verbose)
{
Console.WriteLine("{0}/{1} doesn't exist", root, unqualifiedFileName);
}
//errMgr.IOError(null, ErrorType.NO_SUCH_TEMPLATE, ioe, unqualifiedFileName);
return(null);
}
return(LoadTemplateFile(prefix, unqualifiedFileName, fs));
}
protected void loadSources(DirectoryInfo directory, string filter, Encoding encoding, bool recursive, ICollection <ICharStream> result)
{
Debug.Assert(directory.Exists);
FileInfo[] sources = directory.GetFiles(filter);
foreach (FileInfo file in sources)
{
var stream = new StreamReader(File.OpenRead(file.FullName), encoding);
ICharStream input = new AntlrInputStream(stream);
result.Add(input);
}
if (recursive)
{
DirectoryInfo[] children = directory.GetDirectories();
foreach (DirectoryInfo child in children)
{
loadSources(child, filter, encoding, true, result);
}
}
}
private string ProcessFile(ContentPropertyData editorValue, ContentItemFile file, string currentPath, Guid cuid, Guid puid)
{
// process the file
// no file, invalid file, reject change
if (UploadFileTypeValidator.ValidateFileExtension(file.FileName) == false)
{
return(null);
}
// get the filepath
// in case we are using the old path scheme, try to re-use numbers (bah...)
var filepath = _mediaFileSystem.GetMediaPath(file.FileName, currentPath, cuid, puid); // fs-relative path
using (var filestream = File.OpenRead(file.TempFilePath))
{
_mediaFileSystem.AddFile(filepath, filestream, true); // must overwrite!
var ext = _mediaFileSystem.GetExtension(filepath);
if (_mediaFileSystem.IsImageFile(ext) && ext != ".svg")
{
var preValues = editorValue.PreValues.FormatAsDictionary();
var sizes = preValues.Any() ? preValues.First().Value.Value : string.Empty;
try
{
using (var image = Image.FromStream(filestream))
_mediaFileSystem.GenerateThumbnails(image, filepath, sizes);
}
catch (ArgumentException ex)
{
// send any argument errors caused by the thumbnail generation to the log instead of failing miserably
LogHelper.WarnWithException <ImageCropperPropertyValueEditor>("Could not extract image thumbnails.", ex);
}
}
// all related properties (auto-fill) are managed by ImageCropperPropertyEditor
// when the content is saved (through event handlers)
}
return(filepath);
}
private string ProcessFile(ContentPropertyData editorValue, ContentPropertyFile file, string currentPath, Guid cuid, Guid puid)
{
// process the file
// no file, invalid file, reject change
if (UploadFileTypeValidator.ValidateFileExtension(file.FileName) == false)
{
return(null);
}
// get the filepath
// in case we are using the old path scheme, try to re-use numbers (bah...)
var filepath = _mediaFileSystem.GetMediaPath(file.FileName, currentPath, cuid, puid); // fs-relative path
using (var filestream = File.OpenRead(file.TempFilePath))
{
// TODO: Here it would make sense to do the auto-fill properties stuff but the API doesn't allow us to do that right
// since we'd need to be able to return values for other properties from these methods
_mediaFileSystem.AddFile(filepath, filestream, true); // must overwrite!
}
return(filepath);
}
public static MimeMessage FromStub(EmailMessage msg)
{
MimeMessage outMsg = new MimeMessage();
var from = msg.From.FirstOrDefault();
outMsg.From.Add(from.ToMailAddress());
EmailAddress.IterateBack(msg.To).ForEach(addr => outMsg.To.Add(addr));
if (msg.CC != null && msg.CC.Count != 0)
{
if (!string.IsNullOrEmpty(msg.CC[0].Name) && !string.IsNullOrEmpty(msg.CC[0].Address))
{
EmailAddress.IterateBack(msg.CC).ForEach(addr => outMsg.Cc.Add(addr));
}
}
if (msg.Bcc != null && msg.Bcc.Count != 0)
{
if (!string.IsNullOrEmpty(msg.Bcc[0].Name) && !string.IsNullOrEmpty(msg.Bcc[0].Address))
{
EmailAddress.IterateBack(msg.Bcc).ForEach(addr => outMsg.Bcc.Add(addr));
}
}
outMsg.Subject = msg.Subject;
var body = new TextPart();
if (msg.IsBodyHtml)
{
body = new TextPart("html")
{
Text = msg.Body
};
}
else
{
body = new TextPart("plain")
{
Text = msg.PlainTextBody
};
}
//create the multipart/mixed container to hold the message text and the attachment
var multipart = new Multipart("mixed");
if (msg.Attachments != null || msg.Attachments.Count != 0)
{
//get all attachments from email message
foreach (var msgAttachment in msg.Attachments)
{
var attachment = new MimePart("image", "gif")
{
Content = new MimeContent(IOFile.OpenRead(msgAttachment.ContentStorageAddress), ContentEncoding.Default),
ContentDisposition = new ContentDisposition(ContentDisposition.Attachment),
ContentTransferEncoding = ContentEncoding.Base64,
FileName = msgAttachment.Name
};
multipart.Add(attachment);
}
}
multipart.Add(body);
//set the multipart/mixed as the message body
outMsg.Body = multipart;
return(outMsg);
}
public static File ParseCore(string filePath, CharacterPositionFinder finder, IXmlFlavor flavor, Encoding encoding)
{
using (var reader = new XmlTextReader(new StreamReader(SystemFile.OpenRead(filePath), encoding)))
{
var file = new File
{
Name = filePath,
FooterSpan = CharacterSpan.None, // there is no footer
};
var fileBegin = new LineInfo(reader.LineNumber + 1, reader.LinePosition);
try
{
var dummyRoot = new Container();
// Parse the XML and display the text content of each of the elements.
// as there are XMLs that have the declaration on same line as the root element, we just loop and parse until the end
while (!reader.EOF)
{
Parse(reader, dummyRoot, finder, flavor);
}
var root = dummyRoot.Children.OfType <Container>().Last();
var rootEnd = FixRoot(root, dummyRoot);
var fileEnd = new LineInfo(reader.LineNumber, reader.LinePosition - 1);
var positionAfterLastElement = new LineInfo(rootEnd.LineNumber, rootEnd.LinePosition + 1); // we calculate the next one (either a new line character or a regular one)
file.LocationSpan = new LocationSpan(fileBegin, fileEnd);
if (positionAfterLastElement < fileEnd)
{
file.FooterSpan = GetCharacterSpan(new LocationSpan(positionAfterLastElement, fileEnd), finder);
}
file.Children.Add(root);
}
catch (XmlException ex)
{
// try to adjust location span to include full file content
// but ignore empty files as parsing errors
var lines = SystemFile.ReadLines(filePath).Count();
if (lines == 0)
{
file.LocationSpan = new LocationSpan(LineInfo.None, LineInfo.None);
}
else
{
file.ParsingErrors.Add(new ParsingError
{
ErrorMessage = ex.Message,
Location = new LineInfo(ex.LineNumber, ex.LinePosition),
});
file.LocationSpan = new LocationSpan(new LineInfo(1, 0), new LineInfo(lines + 1, 0));
}
}
return(file);
}
}
static async void Bot_OnMessage(object sender, MessageEventArgs e)
{
try
{
Message message = new Message();
ParseMessage pm = new ParseMessage();
PasteDotaThread pdt = new PasteDotaThread();
pm.ParseUserMessage(message.ReplyToMessage.Text);
switch (pm.ExistBotCommands.Find(x => x.Equals(pm.BotCommand)))
{
case "/paste":
pdt.GetPasteFromNotepad(pm);
await botClient.SendTextMessageAsync(chatId : e.Message.Chat,
text : pdt.MessageText, replyToMessageId : e.Message.MessageId);
break;
case "/d4":
case "/d8":
case "/d10":
case "/d12":
case "/d20":
case "/d100":
var cube = DndCaluclation.GetCube(pm.BotCommand);
DNDResults dndr = new DNDResults();
dndr.SomeResult(pm, cube);
await botClient.SendTextMessageAsync(chatId : e.Message.Chat, text : dndr.TextMessage,
replyToMessageId : e.Message.MessageId, parseMode : ParseMode.Markdown);
dndr.FinalResult(pm, cube);
await botClient.SendTextMessageAsync(chatId : e.Message.Chat, text : dndr.TextMessage,
replyToMessageId : e.Message.MessageId, parseMode : ParseMode.Markdown);
break;
case "/otec":
pdt.GetPasteFromOtecNotepad(pm);
await botClient.SendTextMessageAsync(chatId : e.Message.Chat,
text : pdt.MessageText, replyToMessageId : e.Message.MessageId);
break;
case "/help":
await botClient.SendTextMessageAsync(chatId : e.Message.Chat,
text : "Напиши вот этому человеку @shadowmorex", replyToMessageId : e.Message.MessageId);
break;
case "/fresco":
Quotes quotes = new Quotes(pm);
await using (var file = File.OpenRead(quotes.PathToFile))
{
var iof = new InputOnlineFile(file, "quotes.bpm");
await botClient.SendPhotoAsync(e.Message.Chat, iof, "Все факты достоверны и тщательно проверены администрацией",
replyToMessageId : e.Message.MessageId);
}
break;
case "/test":
await using (var file =
File.OpenRead(@"D:\projects\Valentin_Core\Valentin_Core\resources\img\fresco.jpg"))
{
var iofa = new InputOnlineFile(file, "shit.png");
await botClient.SendPhotoAsync(e.Message.Chat, iofa, "иди нахуй",
replyToMessageId : e.Message.MessageId);
}
break;
}
}
catch (Exception er)
{
await botClient.SendPhotoAsync(chatId : e.Message.Chat, photo :
"http://reactionimage.org/img/gallery/3926393515.jpg",
replyToMessageId : e.Message.MessageId,
caption : "Какая-то хуйня, больше так не делай.\n" +
"Если думаешь, что проблема в боте\n" +
"то вызови автора командой */help*",
parseMode : ParseMode.Markdown);
}
}
