surferHalo
/
October3d55
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
October3d55/M/HTTPWebCommunication/Source/WebCommunication/Private/WebCommunicationBPLibrary.cpp

1795 lines
65 KiB
C++
Raw Normal View History

initial commit
2025-03-10 09:43:27 +08:00
// Copyright 2017-2020 David Romanski(Socke). All Rights Reserved.
#include "WebCommunicationBPLibrary.h"
UWebCommunicationBPLibrary* UWebCommunicationBPLibrary::webcom;
UWebCommunicationBPLibrary::UWebCommunicationBPLibrary(const FObjectInitializer& ObjectInitializer)
: Super(ObjectInitializer) {
webcom = this;
//Delegates example
onhttpRequestCompleteDelegate.AddDynamic(this, &UWebCommunicationBPLibrary::httpRequestCompleteDelegate);
//onhttpFileDownloadDelegate.AddDynamic(this, &UWebCommunicationBPLibrary::httpFileDownloadDelegate);
//onhttpFileUploadDelegate.AddDynamic(this, &UWebCommunicationBPLibrary::httpFileUploadDelegate);
struct ExtensionToMimeMapping {
char const* extension;
char const* mimeType;
};
//found in /etc/mime.types on my linux server
ExtensionToMimeMapping mappings[] = {
{"ez", "application/andrew-inset"},
{"anx", "application/annodex"},
{"atom", "application/atom+xml"},
{"atomcat", "application/atomcat+xml"},
{"atomsrv", "application/atomserv+xml"},
{"lin", "application/bbolin"},
{"cu", "application/cu-seeme"},
{"davmount", "application/davmount+xml"},
{"dcm", "application/dicom"},
{"tsp", "application/dsptype"},
{"es", "application/ecmascript"},
{"spl", "application/futuresplash"},
{"hta", "application/hta"},
{"jar", "application/java-archive"},
{"ser", "application/java-serialized-object"},
{"class", "application/java-vm"},
{"js", "application/javascript"},
{"json", "application/json"},
{"m3g", "application/m3g"},
{"hqx", "application/mac-binhex40"},
{"cpt", "application/mac-compactpro"},
{"nb", "application/mathematica"},
{"nbp", "application/mathematica"},
{"mbox", "application/mbox"},
{"mdb", "application/msaccess"},
{"doc", "application/msword"},
{"dot", "application/msword"},
{"mxf", "application/mxf"},
{"bin", "application/octet-stream"},
{"oda", "application/oda"},
{"ogx", "application/ogg"},
{"one", "application/onenote"},
{"onetoc2", "application/onenote"},
{"onetmp", "application/onenote"},
{"onepkg", "application/onenote"},
{"pdf", "application/pdf"},
{"pgp", "application/pgp-encrypted"},
{"key", "application/pgp-keys"},
{"sig", "application/pgp-signature"},
{"prf", "application/pics-rules"},
{"ps", "application/postscript"},
{"ai", "application/postscript"},
{"eps", "application/postscript"},
{"epsi", "application/postscript"},
{"epsf", "application/postscript"},
{"eps2", "application/postscript"},
{"eps3", "application/postscript"},
{"rar", "application/rar"},
{"rdf", "application/rdf+xml"},
{"rtf", "application/rtf"},
{"stl", "application/sla"},
{"smi", "application/smil"},
{"smil", "application/smil"},
{"xhtml", "application/xhtml+xml"},
{"xht", "application/xhtml+xml"},
{"xml", "application/xml"},
{"xsl", "application/xml"},
{"xsd", "application/xml"},
{"xspf", "application/xspf+xml"},
{"zip", "application/zip"},
{"xlam", "application/vnd.ms-excel.addin.macroEnabled.12"},
{"xlsb", "application/vnd.ms-excel.sheet.binary.macroEnabled.12"},
{"xlsm", "application/vnd.ms-excel.sheet.macroEnabled.12"},
{"xltm", "application/vnd.ms-excel.template.macroEnabled.12"},
{"ppam", "application/vnd.ms-powerpoint.addin.macroEnabled.12"},
{"pptm", "application/vnd.ms-powerpoint.presentation.macroEnabled.12"},
{"sldm", "application/vnd.ms-powerpoint.slide.macroEnabled.12"},
{"ppsm", "application/vnd.ms-powerpoint.slideshow.macroEnabled.12"},
{"potm", "application/vnd.ms-powerpoint.template.macroEnabled.12"},
{"docm", "application/vnd.ms-word.document.macroEnabled.12"},
{"dotm", "application/vnd.ms-word.template.macroEnabled.12"},
{"odc", "application/vnd.oasis.opendocument.chart"},
{"odb", "application/vnd.oasis.opendocument.database"},
{"odf", "application/vnd.oasis.opendocument.formula"},
{"odg", "application/vnd.oasis.opendocument.graphics"},
{"otg", "application/vnd.oasis.opendocument.graphics-template"},
{"odi", "application/vnd.oasis.opendocument.image"},
{"odp", "application/vnd.oasis.opendocument.presentation"},
{"otp", "application/vnd.oasis.opendocument.presentation-template"},
{"ods", "application/vnd.oasis.opendocument.spreadsheet"},
{"ots", "application/vnd.oasis.opendocument.spreadsheet-template"},
{"odm", "application/vnd.oasis.opendocument.text-master"},
{"ott", "application/vnd.oasis.opendocument.text-template"},
{"oth", "application/vnd.oasis.opendocument.text-web"},
{"pptx", "application/vnd.openxmlformats-officedocument.presentationml.presentation"},
{"sldx", "application/vnd.openxmlformats-officedocument.presentationml.slide"},
{"ppsx", "application/vnd.openxmlformats-officedocument.presentationml.slideshow"},
{"potx", "application/vnd.openxmlformats-officedocument.presentationml.template"},
{"xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"},
{"xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"},
{"xltx", "application/vnd.openxmlformats-officedocument.spreadsheetml.template"},
{"xltx", "application/vnd.openxmlformats-officedocument.spreadsheetml.template"},
{"docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document"},
{"dotx", "application/vnd.openxmlformats-officedocument.wordprocessingml.template"},
{"sgl", "application/vnd.stardivision.writer-global"},
{"sti", "application/vnd.sun.xml.impress.template"},
{"wk", "application/x-123"},
{"7z", "application/x-7z-compressed"},
{"abw", "application/x-abiword"},
{"dmg", "application/x-apple-diskimage"},
{"bcpio", "application/x-bcpio"},
{"torrent", "application/x-bittorrent"},
{"cab", "application/x-cab"},
{"cbr", "application/x-cbr"},
{"cbz", "application/x-cbz"},
{"cdf", "application/x-cdf"},
{"cda", "application/x-cdf"},
{"vcd", "application/x-cdlink"},
{"pgn", "application/x-chess-pgn"},
{"mph", "application/x-comsol"},
{"cpio", "application/x-cpio"},
{"csh", "application/x-csh"},
{"deb", "application/x-debian-package"},
{"udeb", "application/x-debian-package"},
{"dcr", "application/x-director"},
{"dir", "application/x-director"},
{"dxr", "application/x-director"},
{"dms", "application/x-dms"},
{"wad", "application/x-doom"},
{"dvi", "application/x-dvi"},
{"pfa", "application/x-font"},
{"pfb", "application/x-font"},
{"gsf", "application/x-font"},
{"pcf", "application/x-font"},
{"pcf.Z", "application/x-font"},
{"woff", "application/x-font-woff"},
{"mm", "application/x-freemind"},
{"spl", "application/x-futuresplash"},
{"gan", "application/x-ganttproject"},
{"gnumeric", "application/x-gnumeric"},
{"sgf", "application/x-go-sgf"},
{"gcf", "application/x-graphing-calculator"},
{"gtar", "application/x-gtar"},
{"tgz", "application/x-gtar-compressed"},
{"taz", "application/x-gtar-compressed"},
{"hdf", "application/x-hdf"},
{"rhtml", "#application/x-httpd-eruby"},
{"phtml", "#application/x-httpd-php"},
{"pht", "#application/x-httpd-php"},
{"php", "#application/x-httpd-php"},
{"phps", "#application/x-httpd-php-source"},
{"php3", "#application/x-httpd-php3"},
{"php3p", "#application/x-httpd-php3-preprocessed"},
{"php4", "#application/x-httpd-php4"},
{"php5", "#application/x-httpd-php5"},
{"hwp", "application/x-hwp"},
{"ica", "application/x-ica"},
{"info", "application/x-info"},
{"ins", "application/x-internet-signup"},
{"isp", "application/x-internet-signup"},
{"iii", "application/x-iphone"},
{"iso", "application/x-iso9660-image"},
{"jam", "application/x-jam"},
{"jnlp", "application/x-java-jnlp-file"},
{"jmz", "application/x-jmol"},
{"chrt", "application/x-kchart"},
{"kil", "application/x-killustrator"},
{"skp", "application/x-koan"},
{"skd", "application/x-koan"},
{"skt", "application/x-koan"},
{"skm", "application/x-koan"},
{"kpr", "application/x-kpresenter"},
{"kpt", "application/x-kpresenter"},
{"ksp", "application/x-kspread"},
{"kwd", "application/x-kword"},
{"kwt", "application/x-kword"},
{"latex", "application/x-latex"},
{"lha", "application/x-lha"},
{"lyx", "application/x-lyx"},
{"lzh", "application/x-lzh"},
{"lzx", "application/x-lzx"},
{"frm", "application/x-maker"},
{"maker", "application/x-maker"},
{"frame", "application/x-maker"},
{"fm", "application/x-maker"},
{"fb", "application/x-maker"},
{"book", "application/x-maker"},
{"fbdoc", "application/x-maker"},
{"md5", "application/x-md5"},
{"mif", "application/x-mif"},
{"m3u8", "application/x-mpegURL"},
{"wmd", "application/x-ms-wmd"},
{"wmz", "application/x-ms-wmz"},
{"com", "application/x-msdos-program"},
{"exe", "application/x-msdos-program"},
{"bat", "application/x-msdos-program"},
{"dll", "application/x-msdos-program"},
{"msi", "application/x-msi"},
{"nc", "application/x-netcdf"},
{"pac", "application/x-ns-proxy-autoconfig"},
{"dat", "application/x-ns-proxy-autoconfig"},
{"nwc", "application/x-nwc"},
{"o", "application/x-object"},
{"oza", "application/x-oz-application"},
{"p7r", "application/x-pkcs7-certreqresp"},
{"crl", "application/x-pkcs7-crl"},
{"pyc", "application/x-python-code"},
{"pyo", "application/x-python-code"},
{"qgs", "application/x-qgis"},
{"shp", "application/x-qgis"},
{"shx", "application/x-qgis"},
{"qtl", "application/x-quicktimeplayer"},
{"rdp", "application/x-rdp"},
{"rpm", "application/x-redhat-package-manager"},
{"rss", "application/x-rss+xml"},
{"rb", "application/x-ruby"},
{"sci", "application/x-scilab"},
{"sce", "application/x-scilab"},
{"xcos", "application/x-scilab-xcos"},
{"sh", "application/x-sh"},
{"sha1", "application/x-sha1"},
{"shar", "application/x-shar"},
{"swf", "application/x-shockwave-flash"},
{"swfl", "application/x-shockwave-flash"},
{"scr", "application/x-silverlight"},
{"sql", "application/x-sql"},
{"sit", "application/x-stuffit"},
{"sitx", "application/x-stuffit"},
{"sv4cpio", "application/x-sv4cpio"},
{"sv4crc", "application/x-sv4crc"},
{"tar", "application/x-tar"},
{"tcl", "application/x-tcl"},
{"gf", "application/x-tex-gf"},
{"pk", "application/x-tex-pk"},
{"texinfo", "application/x-texinfo"},
{"texi", "application/x-texinfo"},
{"~", "application/x-trash"},
{"%", "application/x-trash"},
{"bak", "application/x-trash"},
{"old", "application/x-trash"},
{"sik", "application/x-trash"},
{"t", "application/x-troff"},
{"tr", "application/x-troff"},
{"roff", "application/x-troff"},
{"man", "application/x-troff-man"},
{"me", "application/x-troff-me"},
{"ms", "application/x-troff-ms"},
{"ustar", "application/x-ustar"},
{"src", "application/x-wais-source"},
{"wz", "application/x-wingz"},
{"crt", "application/x-x509-ca-cert"},
{"xcf", "application/x-xcf"},
{"fig", "application/x-xfig"},
{"xpi", "application/x-xpinstall"},
{"amr", "audio/amr"},
{"awb", "audio/amr-wb"},
{"amr", "audio/amr"},
{"awb", "audio/amr-wb"},
{"axa", "audio/annodex"},
{"au", "audio/basic"},
{"snd", "audio/basic"},
{"csd", "audio/csound"},
{"orc", "audio/csound"},
{"sco", "audio/csound"},
{"flac", "audio/flac"},
{"mid", "audio/midi"},
{"midi", "audio/midi"},
{"kar", "audio/midi"},
{"mpga", "audio/mpeg"},
{"mpega", "audio/mpeg"},
{"mp2", "audio/mpeg"},
{"mp3", "audio/mpeg"},
{"m4a", "audio/mpeg"},
{"m3u", "audio/mpegurl"},
{"oga", "audio/ogg"},
{"ogg", "audio/ogg"},
{"spx", "audio/ogg"},
{"sid", "audio/prs.sid"},
{"aif", "audio/x-aiff"},
{"aiff", "audio/x-aiff"},
{"aifc", "audio/x-aiff"},
{"gsm", "audio/x-gsm"},
{"m3u", "audio/x-mpegurl"},
{"wma", "audio/x-ms-wma"},
{"wax", "audio/x-ms-wax"},
{"ra", "audio/x-pn-realaudio"},
{"rm", "audio/x-pn-realaudio"},
{"ram", "audio/x-pn-realaudio"},
{"ra", "audio/x-realaudio"},
{"pls", "audio/x-scpls"},
{"sd2", "audio/x-sd2"},
{"wav", "audio/x-wav"},
{"alc", "chemical/x-alchemy"},
{"cac", "chemical/x-cache"},
{"cache", "chemical/x-cache"},
{"csf", "chemical/x-cache-csf"},
{"cbin", "chemical/x-cactvs-binary"},
{"cascii", "chemical/x-cactvs-binary"},
{"ctab", "chemical/x-cactvs-binary"},
{"cdx", "chemical/x-cdx"},
{"cer", "chemical/x-cerius"},
{"c3d", "chemical/x-chem3d"},
{"chm", "chemical/x-chemdraw"},
{"cif", "chemical/x-cif"},
{"cmdf", "chemical/x-cmdf"},
{"cml", "chemical/x-cml"},
{"cpa", "chemical/x-compass"},
{"bsd", "chemical/x-crossfire"},
{"csml", "chemical/x-csml"},
{"csm", "chemical/x-csml"},
{"ctx", "chemical/x-ctx"},
{"cxf", "chemical/x-cxf"},
{"cef", "chemical/x-cxf"},
{"smi", "#chemical/x-daylight-smiles"},
{"emb", "chemical/x-embl-dl-nucleotide"},
{"embl", "chemical/x-embl-dl-nucleotide"},
{"spc", "chemical/x-galactic-spc"},
{"inp", "chemical/x-gamess-input"},
{"gam", "chemical/x-gamess-input"},
{"gamin", "chemical/x-gamess-input"},
{"fch", "chemical/x-gaussian-checkpoint"},
{"fchk", "chemical/x-gaussian-checkpoint"},
{"cub", "chemical/x-gaussian-cube"},
{"gau", "chemical/x-gaussian-input"},
{"gjc", "chemical/x-gaussian-input"},
{"gjf", "chemical/x-gaussian-input"},
{"gal", "chemical/x-gaussian-log"},
{"gcg", "chemical/x-gcg8-sequence"},
{"gen", "chemical/x-genbank"},
{"hin", "chemical/x-hin"},
{"istr", "chemical/x-isostar"},
{"ist", "chemical/x-isostar"},
{"jdx", "chemical/x-jcamp-dx"},
{"dx", "chemical/x-jcamp-dx"},
{"kin", "chemical/x-kinemage"},
{"mcm", "chemical/x-macmolecule"},
{"mmd", "chemical/x-macromodel-input"},
{"mmod", "chemical/x-macromodel-input"},
{"mol", "chemical/x-mdl-molfile"},
{"rd", "chemical/x-mdl-rdfile"},
{"rxn", "chemical/x-mdl-rxnfile"},
{"sd", "chemical/x-mdl-sdfile"},
{"sdf", "chemical/x-mdl-sdfile"},
{"tgf", "chemical/x-mdl-tgf"},
{"mif", "#chemical/x-mif"},
{"mcif", "chemical/x-mmcif"},
{"mol2", "chemical/x-mol2"},
{"b", "chemical/x-molconn-Z"},
{"gpt", "chemical/x-mopac-graph"},
{"mop", "chemical/x-mopac-input"},
{"mopcrt", "chemical/x-mopac-input"},
{"mpc", "chemical/x-mopac-input"},
{"zmt", "chemical/x-mopac-input"},
{"moo", "chemical/x-mopac-out"},
{"mvb", "chemical/x-mopac-vib"},
{"asn", "chemical/x-ncbi-asn1"},
{"prt", "chemical/x-ncbi-asn1-ascii"},
{"ent", "chemical/x-ncbi-asn1-ascii"},
{"val", "chemical/x-ncbi-asn1-binary"},
{"aso", "chemical/x-ncbi-asn1-binary"},
{"asn", "chemical/x-ncbi-asn1-spec"},
{"pdb", "chemical/x-pdb"},
{"ent", "chemical/x-pdb"},
{"ros", "chemical/x-rosdal"},
{"sw", "chemical/x-swissprot"},
{"vms", "chemical/x-vamas-iso14976"},
{"vmd", "chemical/x-vmd"},
{"xtel", "chemical/x-xtel"},
{"xyz", "chemical/x-xyz"},
{"gif", "image/gif"},
{"ief", "image/ief"},
{"jpeg", "image/jpeg"},
{"jpg", "image/jpeg"},
{"jpe", "image/jpeg"},
{"pcx", "image/pcx"},
{"png", "image/png"},
{"svg", "image/svg+xml"},
{"svgz", "image/svg+xml"},
{"tiff", "image/tiff"},
{"tif", "image/tiff"},
{"djvu", "image/vnd.djvu"},
{"djv", "image/vnd.djvu"},
{"ico", "image/vnd.microsoft.icon"},
{"wbmp", "image/vnd.wap.wbmp"},
{"cr2", "image/x-canon-cr2"},
{"crw", "image/x-canon-crw"},
{"ras", "image/x-cmu-raster"},
{"cdr", "image/x-coreldraw"},
{"pat", "image/x-coreldrawpattern"},
{"cdt", "image/x-coreldrawtemplate"},
{"cpt", "image/x-corelphotopaint"},
{"erf", "image/x-epson-erf"},
{"art", "image/x-jg"},
{"jng", "image/x-jng"},
{"bmp", "image/x-ms-bmp"},
{"nef", "image/x-nikon-nef"},
{"orf", "image/x-olympus-orf"},
{"psd", "image/x-photoshop"},
{"pnm", "image/x-portable-anymap"},
{"pbm", "image/x-portable-bitmap"},
{"pgm", "image/x-portable-graymap"},
{"ppm", "image/x-portable-pixmap"},
{"rgb", "image/x-rgb"},
{"xbm", "image/x-xbitmap"},
{"xpm", "image/x-xpixmap"},
{"xwd", "image/x-xwindowdump"},
{"eml", "message/rfc822"},
{"igs", "model/iges"},
{"iges", "model/iges"},
{"msh", "model/mesh"},
{"mesh", "model/mesh"},
{"silo", "model/mesh"},
{"wrl", "model/vrml"},
{"vrml", "model/vrml"},
{"x3dv", "model/x3d+vrml"},
{"x3d", "model/x3d+xml"},
{"x3db", "model/x3d+binary"},
{"appcache", "text/cache-manifest"},
{"ics", "text/calendar"},
{"icz", "text/calendar"},
{"css", "text/css"},
{"csv", "text/csv"},
{"323", "text/h323"},
{"html", "text/html"},
{"htm", "text/html"},
{"shtml", "text/html"},
{"uls", "text/iuls"},
{"mml", "text/mathml"},
{"asc", "text/plain"},
{"txt", "text/plain"},
{"text", "text/plain"},
{"pot", "text/plain"},
{"brf", "text/plain"},
{"srt", "text/plain"},
{"rtx", "text/richtext"},
{"sct", "text/scriptlet"},
{"wsc", "text/scriptlet"},
{"tm", "text/texmacs"},
{"tsv", "text/tab-separated-values"},
{"jad", "text/vnd.sun.j2me.app-descriptor"},
{"wml", "text/vnd.wap.wml"},
{"wmls", "text/vnd.wap.wmlscript"},
{"bib", "text/x-bibtex"},
{"boo", "text/x-boo"},
{"h++", "text/x-c++hdr"},
{"hpp", "text/x-c++hdr"},
{"hxx", "text/x-c++hdr"},
{"hh", "text/x-c++hdr"},
{"c++", "text/x-c++src"},
{"cpp", "text/x-c++src"},
{"cxx", "text/x-c++src"},
{"cc", "text/x-c++src"},
{"h", "text/x-chdr"},
{"htc", "text/x-component"},
{"csh", "text/x-csh"},
{"c", "text/x-csrc"},
{"d", "text/x-dsrc"},
{"diff", "text/x-diff"},
{"patch", "text/x-diff"},
{"hs", "text/x-haskell"},
{"java", "text/x-java"},
{"ly", "text/x-lilypond"},
{"lhs", "text/x-literate-haskell"},
{"moc", "text/x-moc"},
{"p", "text/x-pascal"},
{"pas", "text/x-pascal"},
{"gcd", "text/x-pcs-gcd"},
{"pl", "text/x-perl"},
{"pm", "text/x-perl"},
{"py", "text/x-python"},
{"scala", "text/x-scala"},
{"etx", "text/x-setext"},
{"sfv", "text/x-sfv"},
{"sh", "text/x-sh"},
{"tcl", "text/x-tcl"},
{"tk", "text/x-tcl"},
{"tex", "text/x-tex"},
{"ltx", "text/x-tex"},
{"sty", "text/x-tex"},
{"cls", "text/x-tex"},
{"vcs", "text/x-vcalendar"},
{"vcf", "text/x-vcard"},
{"3gp", "video/3gpp"},
{"axv", "video/annodex"},
{"dl", "video/dl"},
{"dif", "video/dv"},
{"dv", "video/dv"},
{"fli", "video/fli"},
{"gl", "video/gl"},
{"mpeg", "video/mpeg"},
{"mpg", "video/mpeg"},
{"mpe", "video/mpeg"},
{"ts", "video/MP2T"},
{"mp4", "video/mp4"},
{"qt", "video/quicktime"},
{"mov", "video/quicktime"},
{"ogv", "video/ogg"},
{"webm", "video/webm"},
{"mxu", "video/vnd.mpegurl"},
{"flv", "video/x-flv"},
{"lsf", "video/x-la-asf"},
{"lsx", "video/x-la-asf"},
{"mng", "video/x-mng"},
{"asf", "video/x-ms-asf"},
{"asx", "video/x-ms-asf"},
{"wm", "video/x-ms-wm"},
{"wmv", "video/x-ms-wmv"},
{"wmx", "video/x-ms-wmx"},
{"wvx", "video/x-ms-wvx"},
{"avi", "video/x-msvideo"},
{"movie", "video/x-sgi-movie"},
{"mpv", "video/x-matroska"},
{"mkv", "video/x-matroska"},
{"ice", "x-conference/x-cooltalk"},
{"sisx", "x-epoc/x-sisx-app"},
{"vrm", "x-world/x-vrml"},
{"vrml", "x-world/x-vrml"},
{"wrl", "x-world/x-vrml"}
};
for (auto const& m : mappings) {
mimeTypes.Add(m.extension, m.mimeType);
}
}
UWebCommunicationBPLibrary::~UWebCommunicationBPLibrary() {}
/*Delegate functions*/
void UWebCommunicationBPLibrary::httpRequestCompleteDelegate(const FString dataString, const TArray<FString>& dataArray, const TArray<FString>& header, const int32 statusCode, const TArray<uint8>& byteData, const FString requestID) {
toCancelRequests.Remove(requestID);
startedRequests.Remove(requestID);
}
void UWebCommunicationBPLibrary::httpRequestCompleteGoogleInfoDelegate(const FString fileName, const int64 fileSizeInBytes, const int32 statusCode, const FString downloadID, const FString requestID){}
//void UWebCommunicationBPLibrary::httpFileProgressDelegate(const float size, const int32 bytesSent, const float percentUpload, const int32 bytesReceived, const float percentDownload) {}
void UWebCommunicationBPLibrary::httpFileDownloadDelegate(const float size, const float megaBytesReceived, const float percentDownload, const float megaBit, const FString requestID) {}
void UWebCommunicationBPLibrary::httpFileUploadDelegate(const float size, const int32 bytesSent, const float percentUpload, const FString requestID) {}
void UWebCommunicationBPLibrary::httpServerSendEventDelegate(const FString response, const FString requestID){}
//UWebCommunicationBPLibrary* UWebCommunicationBPLibrary::getTarget() {
// return webcom;
//}
UWebCommunicationBPLibrary* UWebCommunicationBPLibrary::getWebCommunicationTarget() {
return webcom;
}
void UWebCommunicationBPLibrary::cancelRequest(FString requestID) {
UWebCommunicationBPLibrary::getWebCommunicationTarget()->toCancelRequests.Add(requestID, requestID);
if (UWebCommunicationBPLibrary::getWebCommunicationTarget()->startedRequests.Find(requestID) != nullptr) {
(*UWebCommunicationBPLibrary::getWebCommunicationTarget()->startedRequests.Find(requestID))->CancelRequest();
}
}
int32 UWebCommunicationBPLibrary::megabyteToByte(int32 mb) {
return (mb * 1024 * 1024);
}
float UWebCommunicationBPLibrary::byteToMegabyte(int32 byte) {
return ((float)byte / 1024 / 1024);
}
void UWebCommunicationBPLibrary::searchUploadLeftovers(EHTTPWebComFileUpload DirectoryType, FString filePath, bool& foundLeftovers, int64& originalFileSize)
{
foundLeftovers = false;
originalFileSize = 0;
FString dir;
if (DirectoryType == EHTTPWebComFileUpload::E_ad) {
dir = FPaths::ConvertRelativePathToFull(filePath);
}
else {
FString gameDir = FPaths::ProjectDir();
dir = FPaths::ConvertRelativePathToFull(gameDir + filePath);
}
FArchive* reader = IFileManager::Get().CreateFileReader(*dir);
if (reader == nullptr) {
return;
}
if (reader->TotalSize() < 37) {
reader->Close();
delete reader;
return;
}
TArray<char> data;
for (int32 i = 0; i < 20; i++)
{
reader->Seek(reader->TotalSize() - 37-i);
data.AddUninitialized(37+i);
reader->Serialize(data.GetData(), 37+i);
if (data[0] == '-' &&
data[1] == '-' &&
data[2] == '-' &&
data[3] == '-' &&
data[4] == '-' &&
data[5] == '-') {
break;
}
else {
data.Empty();
if (reader->TotalSize() < 37 + i) {
break;
}
}
}
reader->Close();
delete reader;
if (data.Num() < 35) {
return;
}
data.Add(0x00);// null-terminator
FString httpUploadfooter = UTF8_TO_TCHAR(data.GetData());
httpUploadfooter = httpUploadfooter.TrimEnd();
if (httpUploadfooter.StartsWith("------UE4WebCommunicationPlugin_") == false || httpUploadfooter.EndsWith("--") == false) {
return;
}
httpUploadfooter.RemoveFromStart("------UE4WebCommunicationPlugin_");
httpUploadfooter.RemoveFromEnd("--");
if (httpUploadfooter.Len() < 1 || httpUploadfooter.IsNumeric() == false) {
return;
}
//int64 originalFileLength = FCString::Atoi64(*httpUploadfooter);
originalFileSize = FCString::Atoi64(*httpUploadfooter);
if (originalFileSize > 0) {
foundLeftovers = true;
}
return;
}
bool UWebCommunicationBPLibrary::repairFileAfterUpload(EHTTPWebComFileUpload DirectoryType, FString filePath)
{
bool foundLeftovers = false;
int64 originalFileSize = 0;
searchUploadLeftovers(DirectoryType, filePath, foundLeftovers, originalFileSize);
if (foundLeftovers == false || originalFileSize == 0) {
return false;
}
FString dir;
if (DirectoryType == EHTTPWebComFileUpload::E_ad) {
dir = FPaths::ConvertRelativePathToFull(filePath);
}
else {
FString gameDir = FPaths::ProjectDir();
dir = FPaths::ConvertRelativePathToFull(gameDir + filePath);
}
if (FPlatformFileManager::Get().GetPlatformFile().FileSize(*dir) < originalFileSize) {
return false;
}
IFileHandle* f = FPlatformFileManager::Get().GetPlatformFile().OpenWrite(*dir, true, true);
if (f != nullptr) {
bool truncate = f->Truncate(originalFileSize);
f->Flush();
if (truncate) {
UE_LOG(LogTemp, Display, TEXT("UWebCommunicationBPLibrary: truncate okay: %s"), *dir);
}
else {
UE_LOG(LogTemp, Display, TEXT("UWebCommunicationBPLibrary: truncate fail: %s"), *dir);
}
delete f;
}
return false;
}
void UWebCommunicationBPLibrary::getMimeTypeByFile(EHTTPWebComFileUpload DirectoryType, FString filePath, FString& mimeType, bool& success){
mimeType.Empty();
FString dir;
if (DirectoryType == EHTTPWebComFileUpload::E_ad) {
dir = FPaths::ConvertRelativePathToFull(filePath);
}
else {
FString gameDir = FPaths::ProjectDir();
dir = FPaths::ConvertRelativePathToFull(gameDir + filePath);
}
if (FPaths::FileExists(*dir) == false) {
success = false;
return;
}
FString extension = FPaths::GetExtension(dir);
if (UWebCommunicationBPLibrary::webcom->mimeTypes.Find(extension) == nullptr) {
success = false;
return;
}
mimeType = *UWebCommunicationBPLibrary::webcom->mimeTypes.Find(extension);
success = true;
}
TMap<FString, FString> UWebCommunicationBPLibrary::getMimeTypeMap(){
return UWebCommunicationBPLibrary::webcom->mimeTypes;
}
void UWebCommunicationBPLibrary::addRequestToTruncateThread(FhttpRequest& httpRequest)
{
if (truncateUploadedFileThread == nullptr) {
truncateUploadedFileThread = new FWebComTruncateUploadedFileThread();
}
truncateUploadedFileThread->addRequest(httpRequest);
}
bool UWebCommunicationBPLibrary::isFileBlocked(FString filePath)
{
if (truncateUploadedFileThread == nullptr) {
return false;
}
return truncateUploadedFileThread->blockedFiles.Contains(filePath);
}
void UWebCommunicationBPLibrary::executeHttpRequests(TArray<struct FhttpRequest> httpRequests, UWebCommunicationBPLibrary*& WebCommunicationTarget) {
UWebCommunicationBPLibrary::webcom->startRequests(httpRequests);
WebCommunicationTarget = UWebCommunicationBPLibrary::webcom;
}
int32 UWebCommunicationBPLibrary::CreateHttpRequestGET(TArray<struct FhttpRequest> otherHttpRequests, FString url, TMap<FString, FString> header, FString optionalRequestID, bool bindServerSendEvent, TArray<struct FhttpRequest>& httpRequests, FString& requestID) {
//webcom->runRequestProgress = true;
requestID = optionalRequestID;
if (requestID.IsEmpty())
requestID = FGuid::NewGuid().ToString();
if (url.Len() < 3) {
UE_LOG(LogTemp, Error, TEXT("Cancel Request : URL to short."));
webcom->onhttpRequestCompleteDelegate.Broadcast("", TArray<FString>(), TArray<FString>(), 400, TArray<uint8>(), requestID);
return 400;
}
FhttpRequest httpRequest;
httpRequest.requestType = EHTTPWebComRequestType::GET;
httpRequest.url = url;
httpRequest.header = header;
httpRequest.bindServerSendEvent = bindServerSendEvent;
UWebCommunicationRequestCompleteObject* requestObject = NewObject<UWebCommunicationRequestCompleteObject>(UWebCommunicationRequestCompleteObject::StaticClass());
requestObject->setRequestID(requestID, httpRequest, UWebCommunicationBPLibrary::getWebCommunicationTarget());
httpRequest.request = requestObject;
otherHttpRequests.Add(httpRequest);
httpRequests = otherHttpRequests;
return 0;
}
int32 UWebCommunicationBPLibrary::CreateHttpRequestGETDownload(TArray<struct FhttpRequest>& httpRequests, FString& requestID, TArray<struct FhttpRequest> otherHttpRequests, FString url, TMap<FString, FString> header, EHTTPWebComFileDownloadResumeType actionIfFileExists, EHTTPWebComFileUpload DirectoryType, FString filePath, FString optionalRequestID) {
if (filePath.IsEmpty()) {
UE_LOG(LogTemp, Error, TEXT("CreateHttpRequestGETDownload: FilePath not set."));
webcom->onhttpRequestCompleteDelegate.Broadcast("", TArray<FString>(), TArray<FString>(), 400, TArray<uint8>(), requestID);
return 400;
}
FString dir;
if (DirectoryType == EHTTPWebComFileUpload::E_ad) {
dir = FPaths::ConvertRelativePathToFull(filePath);
}
else {
FString gameDir = FPaths::ProjectDir();
dir = FPaths::ConvertRelativePathToFull(gameDir + filePath);
}
if (FPaths::DirectoryExists(FPaths::GetPath(dir)) == false) {
UE_LOG(LogTemp, Error, TEXT("CreateHttpRequestGETDownload: Directory does not exist."));
webcom->onhttpRequestCompleteDelegate.Broadcast("", TArray<FString>(), TArray<FString>(), 400, TArray<uint8>(), requestID);
return 400;
}
requestID = optionalRequestID;
if (requestID.IsEmpty())
requestID = FGuid::NewGuid().ToString();
if (url.Len() < 3) {
UE_LOG(LogTemp, Error, TEXT("Cancel Request : URL to short."));
webcom->onhttpRequestCompleteDelegate.Broadcast("", TArray<FString>(), TArray<FString>(), 400, TArray<uint8>(), requestID);
return 400;
}
FhttpRequest httpRequest;
httpRequest.requestType = EHTTPWebComRequestType::GET;
httpRequest.url = url;
UWebCommunicationRequestCompleteObject* requestObject = NewObject<UWebCommunicationRequestCompleteObject>(UWebCommunicationRequestCompleteObject::StaticClass());
requestObject->setRequestID(requestID, httpRequest, UWebCommunicationBPLibrary::getWebCommunicationTarget());
requestObject->setFileCancelResumeDownloadDir(dir);
switch (actionIfFileExists)
{
case EHTTPWebComFileDownloadResumeType::E_NOT_OVERWRITE:
if (FPaths::FileExists(dir)) {
UE_LOG(LogTemp, Warning, TEXT("CreateHttpRequestGETDownload: File exist. Cancel download."));
webcom->onhttpRequestCompleteDelegate.Broadcast("", TArray<FString>(), TArray<FString>(), 400, TArray<uint8>(), requestID);
return 400;
}
break;
case EHTTPWebComFileDownloadResumeType::E_OVERWRITE:
FPlatformFileManager::Get().GetPlatformFile().DeleteFile(*dir);
break;
case EHTTPWebComFileDownloadResumeType::E_RESUME:
requestObject->setFileCancelResumeDownloadByteStart(FPlatformFileManager::Get().GetPlatformFile().FileSize(*dir));
break;
}
httpRequest.request = requestObject;
otherHttpRequests.Add(httpRequest);
httpRequests = otherHttpRequests;
return 0;
}
int32 UWebCommunicationBPLibrary::CreateHttpRequestGETLowRamDownload(TArray<struct FhttpRequest>& httpRequests, FString& requestID, TArray<struct FhttpRequest> otherHttpRequests, FString url, TMap<FString, FString> header, EHTTPWebComFileDownloadResumeType actionIfFileExists, EHTTPWebComFileUpload DirectoryType, FString filePath, int32 fileSize, FString optionalRequestID) {
if (filePath.IsEmpty()) {
UE_LOG(LogTemp, Error, TEXT("CreateHttpRequestGETLowRamDownload: FilePath not set."));
webcom->onhttpRequestCompleteDelegate.Broadcast("", TArray<FString>(), TArray<FString>(), 400, TArray<uint8>(), requestID);
return 400;
}
FString dir;
if (DirectoryType == EHTTPWebComFileUpload::E_ad) {
dir = FPaths::ConvertRelativePathToFull(filePath);
}
else {
FString gameDir = FPaths::ProjectDir();
dir = FPaths::ConvertRelativePathToFull(gameDir + filePath);
}
if (FPaths::DirectoryExists(FPaths::GetPath(dir)) == false) {
UE_LOG(LogTemp, Error, TEXT("CreateHttpRequestGETLowRamDownload: Directory does not exist."));
webcom->onhttpRequestCompleteDelegate.Broadcast("", TArray<FString>(), TArray<FString>(), 400, TArray<uint8>(), requestID);
return 400;
}
requestID = optionalRequestID;
if (requestID.IsEmpty())
requestID = FGuid::NewGuid().ToString();
if (url.Len() < 3) {
UE_LOG(LogTemp, Error, TEXT("Cancel Request : URL to short."));
webcom->onhttpRequestCompleteDelegate.Broadcast("", TArray<FString>(), TArray<FString>(), 400, TArray<uint8>(), requestID);
return 400;
}
FhttpRequest httpRequest;
httpRequest.requestType = EHTTPWebComRequestType::GETLowRamDownload;
httpRequest.url = url;
httpRequest.header = header;
UWebCommunicationRequestCompleteObject* requestObject = NewObject<UWebCommunicationRequestCompleteObject>(UWebCommunicationRequestCompleteObject::StaticClass());
requestObject->setRequestID(requestID, httpRequest, UWebCommunicationBPLibrary::getWebCommunicationTarget());
requestObject->setFileCancelResumeDownloadBytePartSize(fileSize);
requestObject->setFileCancelResumeDownloadDir(dir);
switch (actionIfFileExists)
{
case EHTTPWebComFileDownloadResumeType::E_NOT_OVERWRITE:
if (FPaths::FileExists(dir)) {
UE_LOG(LogTemp, Warning, TEXT("CreateHttpRequestGETLowRamDownload: File exist. Cancel download."));
webcom->onhttpRequestCompleteDelegate.Broadcast("", TArray<FString>(), TArray<FString>(), 400, TArray<uint8>(), requestID);
return 400;
}
break;
case EHTTPWebComFileDownloadResumeType::E_OVERWRITE:
FPlatformFileManager::Get().GetPlatformFile().DeleteFile(*dir);
break;
case EHTTPWebComFileDownloadResumeType::E_RESUME:
requestObject->setFileCancelResumeDownloadByteStart(FPlatformFileManager::Get().GetPlatformFile().FileSize(*dir));
break;
}
httpRequest.request = requestObject;
otherHttpRequests.Add(httpRequest);
httpRequests = otherHttpRequests;
return 0;
}
int32 UWebCommunicationBPLibrary::CreateHttpRequestGoogleDrive(TArray<struct FhttpRequest> otherHttpRequests, FString downloadID, FString optionalRequestID, int64 optionalFileSizeInByte, TArray<struct FhttpRequest>& httpRequests, FString& requestID) {
if (downloadID.IsEmpty()) {
UE_LOG(LogTemp, Error, TEXT("No downloadId in CreateHttpRequestGoogleDrive."));
webcom->onhttpRequestCompleteGoogleInfoDelegate.Broadcast("", 0,400, downloadID,requestID);
return 400;
}
requestID = optionalRequestID;
if (requestID.IsEmpty())
requestID = FGuid::NewGuid().ToString();
FString url = "https://drive.google.com/uc?id=" + downloadID + "&export=download";
FhttpRequest httpRequest;
httpRequest.requestType = EHTTPWebComRequestType::GET;
httpRequest.url = url;
UWebCommunicationRequestCompleteObject* requestObject = NewObject<UWebCommunicationRequestCompleteObject>(UWebCommunicationRequestCompleteObject::StaticClass());
requestObject->setRequestID(requestID, httpRequest, UWebCommunicationBPLibrary::getWebCommunicationTarget());
requestObject->setDownloadID(downloadID);
requestObject->setMultiStepDownload(1);
requestObject->setMultiStepDownloadType(EMultiStepType::GOOGLE);
requestObject->setHTMLFileSize(optionalFileSizeInByte);
httpRequest.request = requestObject;
otherHttpRequests.Add(httpRequest);
httpRequests = otherHttpRequests;
return 0;
}
int32 UWebCommunicationBPLibrary::CreateHttpRequestGoogleDriveFileInfo(TArray<struct FhttpRequest> otherHttpRequests, FString downloadID, FString optionalRequestID, TArray<struct FhttpRequest>& httpRequests, FString& requestID) {
if (downloadID.IsEmpty()) {
UE_LOG(LogTemp, Error, TEXT("No downloadId in CreateHttpRequestGoogleDriveFileInfo."));
webcom->onhttpRequestCompleteGoogleInfoDelegate.Broadcast("", 0, 400, downloadID, requestID);
return 400;
}
requestID = optionalRequestID;
if (requestID.IsEmpty())
requestID = FGuid::NewGuid().ToString();
FString url = "https://drive.google.com/file/d/" + downloadID + "/view";
FhttpRequest httpRequest;
httpRequest.requestType = EHTTPWebComRequestType::GET;
httpRequest.url = url;
UWebCommunicationRequestCompleteObject* requestObject = NewObject<UWebCommunicationRequestCompleteObject>(UWebCommunicationRequestCompleteObject::StaticClass());
requestObject->setRequestID(requestID, httpRequest, UWebCommunicationBPLibrary::getWebCommunicationTarget());
requestObject->setDownloadID(downloadID);
requestObject->setMultiStepDownloadType(EMultiStepType::GOOGLE_INFO);
httpRequest.request = requestObject;
otherHttpRequests.Add(httpRequest);
httpRequests = otherHttpRequests;
return 0;
}
int32 UWebCommunicationBPLibrary::CreateHttpRequestAnonfiles(TArray<struct FhttpRequest> otherHttpRequests, FString url, FString optionalRequestID, TArray<struct FhttpRequest>& httpRequests, FString& requestID) {
requestID = optionalRequestID;
if (requestID.IsEmpty())
requestID = FGuid::NewGuid().ToString();
if (url.Len() < 3) {
UE_LOG(LogTemp, Error, TEXT("Cancel Request : URL to short."));
webcom->onhttpRequestCompleteDelegate.Broadcast("", TArray<FString>(), TArray<FString>(), 400, TArray<uint8>(), requestID);
return 400;
}
FhttpRequest httpRequest;
httpRequest.requestType = EHTTPWebComRequestType::GET;
httpRequest.url = url;
UWebCommunicationRequestCompleteObject* requestObject = NewObject<UWebCommunicationRequestCompleteObject>(UWebCommunicationRequestCompleteObject::StaticClass());
requestObject->setRequestID(requestID, httpRequest, UWebCommunicationBPLibrary::getWebCommunicationTarget());
requestObject->setMultiStepDownload(1);
requestObject->setMultiStepDownloadType(EMultiStepType::ANONFILE);
httpRequest.request = requestObject;
otherHttpRequests.Add(httpRequest);
httpRequests = otherHttpRequests;
return 0;
}
int32 UWebCommunicationBPLibrary::CreateHttpRequestPOST(TArray<struct FhttpRequest> otherHttpRequests, FString url, TMap<FString, FString> header, TMap<FString, FString> POSTData, FString optionalRequestID, bool bindServerSendEvent, TArray<struct FhttpRequest>& httpRequests, FString& requestID) {
requestID = optionalRequestID;
if (requestID.IsEmpty())
requestID = FGuid::NewGuid().ToString();
if (url.Len() < 3) {
UE_LOG(LogTemp, Error, TEXT("Cancel Request : URL to short."));
webcom->onhttpRequestCompleteDelegate.Broadcast("", TArray<FString>(), TArray<FString>(), 400, TArray<uint8>(), requestID);
return 400;
}
FhttpRequest httpRequest;
httpRequest.requestType = EHTTPWebComRequestType::POST;
httpRequest.url = url;
httpRequest.header = header;
httpRequest.POSTData = POSTData;
httpRequest.bindServerSendEvent = bindServerSendEvent;
UWebCommunicationRequestCompleteObject* requestObject = NewObject<UWebCommunicationRequestCompleteObject>(UWebCommunicationRequestCompleteObject::StaticClass());
requestObject->setRequestID(requestID, httpRequest, UWebCommunicationBPLibrary::getWebCommunicationTarget());
httpRequest.request = requestObject;
otherHttpRequests.Add(httpRequest);
httpRequests = otherHttpRequests;
return 0;
}
void UWebCommunicationBPLibrary::CreateHttpRequestIndividual(TArray<struct FhttpRequest> otherHttpRequests, FString url, TMap<FString, FString> header,
add picoxr plugin
2025-07-29 14:53:32 +08:00
FString verb, EHTTPWebComIndividualType contentBodyType, FString contentBody,TArray<uint8> binaryContent, FString optionalRequestID,
initial commit
2025-03-10 09:43:27 +08:00
TArray<struct FhttpRequest>& httpRequests, FString& requestID, bool addContentLengthHeader, bool bindDownloadProgressEvent, bool bindUploadProgressEvent, bool bindServerSendEvent) {
UAsyncNodeWebCom* asyncNodeHttpRequest = webcom->getUAsyncNodeHttpRequest(requestID);
if (header.Num() == 0) {
UE_LOG(LogTemp, Error, TEXT("Cancel Request : You have not specified a header. An HTTP request does not work without a header. Add headers like user-agent,Content-Type,Content-Length"));
fireErrorMessageInGameThread(asyncNodeHttpRequest, 400, requestID);
return;
}
if (header.Find("Content-Type") == nullptr) {
UE_LOG(LogTemp, Error, TEXT("Cancel Request : The Content-Type header is missing. This can cause a crash in some UE versions. Therefore the request is not executed. Please also pay attention to upper and lower case."));
fireErrorMessageInGameThread(asyncNodeHttpRequest, 400, requestID);
return;
}
if (url.Len() < 3) {
UE_LOG(LogTemp, Error, TEXT("Cancel Request : URL to short."));
fireErrorMessageInGameThread(asyncNodeHttpRequest, 400, requestID);
return;
}
verb = verb.ToUpper();
if (!verb.Equals("GET") && !verb.Equals("HEAD") && !verb.Equals("POST") && !verb.Equals("PUT") && !verb.Equals("DELETE")
&& !verb.Equals("TRACE") && !verb.Equals("OPTIONS") && !verb.Equals("CONNECT") && !verb.Equals("PATCH")) {
UE_LOG(LogTemp, Error, TEXT("Cancel Request : Wrong verb. Possible values:GET,HEAD,POST,PUT,DELETE,TRACE,OPTIONS,CONNECT,PATCH"));
fireErrorMessageInGameThread(asyncNodeHttpRequest, 400, requestID);
return;
}
if (addContentLengthHeader == true) {
if (verb.Equals("GET")) {
UE_LOG(LogTemp, Warning, TEXT("WebCom Plugin: Setting a Content-Length header for a GET request can lead to an error on the server. "));
}
if (contentBody.IsEmpty()) {
UE_LOG(LogTemp, Warning, TEXT("WebCom Plugin: Setting a Content-Length header with the value 0 can lead to an error on the server. "));
}
FTCHARToUTF8 Convert(*contentBody);
header.Add("Content-Length", FString::FromInt(Convert.Length()));
}
requestID = optionalRequestID;
if (requestID.IsEmpty())
requestID = FGuid::NewGuid().ToString();
FhttpRequest httpRequest;
add picoxr plugin
2025-07-29 14:53:32 +08:00
switch (contentBodyType)
{
case EHTTPWebComIndividualType::E_STRING:
initial commit
2025-03-10 09:43:27 +08:00
httpRequest.requestType = EHTTPWebComRequestType::INDIVIDUAL;
add picoxr plugin
2025-07-29 14:53:32 +08:00
break;
case EHTTPWebComIndividualType::E_STREAM:
initial commit
2025-03-10 09:43:27 +08:00
httpRequest.requestType = EHTTPWebComRequestType::INDIVIDUAL_STREAM;
add picoxr plugin
2025-07-29 14:53:32 +08:00
break;
case EHTTPWebComIndividualType::E_BYTES:
httpRequest.requestType = EHTTPWebComRequestType::INDIVIDUAL_BYTES;
break;
initial commit
2025-03-10 09:43:27 +08:00
}
add picoxr plugin
2025-07-29 14:53:32 +08:00
initial commit
2025-03-10 09:43:27 +08:00
httpRequest.url = url;
httpRequest.header = header;
httpRequest.verb = verb;
httpRequest.content = contentBody;
add picoxr plugin
2025-07-29 14:53:32 +08:00
httpRequest.binaryContent = binaryContent;
initial commit
2025-03-10 09:43:27 +08:00
httpRequest.bindDownloadProgressEvent = bindDownloadProgressEvent;
httpRequest.bindUploadProgressEvent = bindUploadProgressEvent;
httpRequest.bindServerSendEvent = bindServerSendEvent;
UWebCommunicationRequestCompleteObject* requestObject = NewObject<UWebCommunicationRequestCompleteObject>(UWebCommunicationRequestCompleteObject::StaticClass());
requestObject->setRequestID(requestID, httpRequest, UWebCommunicationBPLibrary::getWebCommunicationTarget());
httpRequest.request = requestObject;
otherHttpRequests.Add(httpRequest);
httpRequests = otherHttpRequests;
}
int32 UWebCommunicationBPLibrary::CreateHttpRequestFileUploadPOST(TArray<struct FhttpRequest> otherHttpRequests, FString url, TMap<FString, FString> header, EHTTPWebComFileUpload DirectoryType, FString filePath, FString fileID, TMap<FString, FString> POSTData, FString optionalRequestID, TArray<struct FhttpRequest>& httpRequests, FString& requestID) {
TArray<FString> filePaths;
filePaths.Add(filePath);
TArray<FString> fileIDs;
fileIDs.Add(fileID);
return CreateHttpRequestFileMultiUploadPOST(otherHttpRequests, url, header, DirectoryType, filePaths, fileIDs, POSTData, optionalRequestID, httpRequests, requestID);
}
int32 UWebCommunicationBPLibrary::CreateHttpRequestFileMultiUploadPOST(TArray<struct FhttpRequest> otherHttpRequests, FString url, TMap<FString, FString> header, EHTTPWebComFileUpload DirectoryType, TArray<FString> filePaths, TArray<FString> fileIDs, TMap<FString, FString> POSTData, FString optionalRequestID, TArray<struct FhttpRequest>& httpRequests, FString& requestID){
requestID = optionalRequestID;
if (requestID.IsEmpty())
requestID = FGuid::NewGuid().ToString();
if (url.Len() < 3) {
UE_LOG(LogTemp, Error, TEXT("Cancel Request : URL to short."));
webcom->onhttpRequestCompleteDelegate.Broadcast("", TArray<FString>(), TArray<FString>(), 400, TArray<uint8>(), requestID);
return 400;
}
if (fileIDs.Num() == 0) {
UE_LOG(LogTemp, Error, TEXT("Cancel Request : File ID is missing"));
webcom->onhttpRequestCompleteDelegate.Broadcast("", TArray<FString>(), TArray<FString>(), 400, TArray<uint8>(), requestID);
return 400;
}
FhttpRequest httpRequest;
httpRequest.requestType = EHTTPWebComRequestType::POST_UPLOAD;
httpRequest.url = url;
httpRequest.header = header;
httpRequest.POSTData = POSTData;
httpRequest.DirectoryType = DirectoryType;
httpRequest.filePaths = filePaths;
httpRequest.fileID = fileIDs[0];
httpRequest.fileIDs = fileIDs;
UWebCommunicationRequestCompleteObject* requestObject = NewObject<UWebCommunicationRequestCompleteObject>(UWebCommunicationRequestCompleteObject::StaticClass());
requestObject->setRequestID(requestID, httpRequest, UWebCommunicationBPLibrary::getWebCommunicationTarget());
httpRequest.request = requestObject;
otherHttpRequests.Add(httpRequest);
httpRequests = otherHttpRequests;
return 0;
}
int32 UWebCommunicationBPLibrary::CreateHttpRequestFileUploadPUT(TArray<struct FhttpRequest> otherHttpRequests, FString url, TMap<FString, FString> header, EHTTPWebComFileUpload DirectoryType, FString filePath, FString fileID, EHTTPWebComFileUploadType uploadType, FString optionalRequestID, TArray<struct FhttpRequest>& httpRequests, FString& requestID) {
requestID = optionalRequestID;
if (requestID.IsEmpty())
requestID = FGuid::NewGuid().ToString();
if (url.Len() < 3) {
UE_LOG(LogTemp, Error, TEXT("Cancel Request : URL to short."));
webcom->onhttpRequestCompleteDelegate.Broadcast("", TArray<FString>(), TArray<FString>(), 400, TArray<uint8>(), requestID);
return 400;
}
FhttpRequest httpRequest;
switch (uploadType)
{
case EHTTPWebComFileUploadType::PUT_STREAM_MP:
httpRequest.requestType = EHTTPWebComRequestType::PUT_STREAM_MP;
break;
case EHTTPWebComFileUploadType::PUT_STREAM_BLANK:
httpRequest.requestType = EHTTPWebComRequestType::PUT_STREAM_BLANK;
break;
case EHTTPWebComFileUploadType::PUT_STREAM_COPY:
httpRequest.requestType = EHTTPWebComRequestType::PUT_STREAM_COPY;
break;
default:
httpRequest.requestType = EHTTPWebComRequestType::PUT;
break;
}
httpRequest.url = url;
httpRequest.header = header;
httpRequest.DirectoryType = DirectoryType;
httpRequest.filePath = filePath;
httpRequest.fileID = fileID;
UWebCommunicationRequestCompleteObject* requestObject = NewObject<UWebCommunicationRequestCompleteObject>(UWebCommunicationRequestCompleteObject::StaticClass());
requestObject->setRequestID(requestID, httpRequest, UWebCommunicationBPLibrary::getWebCommunicationTarget());
httpRequest.request = requestObject;
otherHttpRequests.Add(httpRequest);
httpRequests = otherHttpRequests;
return 0;
}
int32 UWebCommunicationBPLibrary::CreateHttpRequestFileMultiUploadPUT(TArray<struct FhttpRequest> otherHttpRequests, FString url, TMap<FString, FString> header,
EHTTPWebComFileUpload DirectoryType, TArray<FString> filePaths, TArray<FString> fileIDs, FString optionalRequestID, TArray<struct FhttpRequest>& httpRequests, FString& requestID) {
requestID = optionalRequestID;
if (requestID.IsEmpty())
requestID = FGuid::NewGuid().ToString();
if (url.Len() < 3) {
UE_LOG(LogTemp, Error, TEXT("Cancel Request : URL to short."));
webcom->onhttpRequestCompleteDelegate.Broadcast("", TArray<FString>(), TArray<FString>(), 400, TArray<uint8>(), requestID);
return 400;
}
if (fileIDs.Num() == 0) {
UE_LOG(LogTemp, Error, TEXT("Cancel Request : File ID is missing"));
webcom->onhttpRequestCompleteDelegate.Broadcast("", TArray<FString>(), TArray<FString>(), 400, TArray<uint8>(), requestID);
return 400;
}
FhttpRequest httpRequest;
httpRequest.requestType = EHTTPWebComRequestType::PUT;
httpRequest.url = url;
httpRequest.header = header;
httpRequest.DirectoryType = DirectoryType;
httpRequest.filePaths = filePaths;
httpRequest.fileID = fileIDs[0];
httpRequest.fileIDs = fileIDs;
UWebCommunicationRequestCompleteObject* requestObject = NewObject<UWebCommunicationRequestCompleteObject>(UWebCommunicationRequestCompleteObject::StaticClass());
requestObject->setRequestID(requestID, httpRequest, UWebCommunicationBPLibrary::getWebCommunicationTarget());
httpRequest.request = requestObject;
otherHttpRequests.Add(httpRequest);
httpRequests = otherHttpRequests;
return 0;
}
void UWebCommunicationBPLibrary::byteDataToFile(EHTTPWebComFileBytesToFileActionType fileAction, TArray<uint8> byteData, EHTTPWebComFileUpload DirectoryType, FString filePath) {
FfileToByteStruct fileToByteStruct;
fileToByteStruct.fileAction = fileAction;
fileToByteStruct.byteData = byteData;
fileToByteStruct.DirectoryType = DirectoryType;
fileToByteStruct.filePath = filePath;
UWebCommunicationBPLibrary::getWebCommunicationTarget()->getByteToFileThread()->saveFile(fileToByteStruct);
}
void UWebCommunicationBPLibrary::addPersistentHTTPRequestHeader(FString id, FString value) {
if (id.IsEmpty()) {
UE_LOG(LogTemp, Error, TEXT("UWebCommunicationBPLibrary (addPersistentHTTPRequestHeader): Id not set."));
return;
}
if (value.IsEmpty()) {
UE_LOG(LogTemp, Display, TEXT("UWebCommunicationBPLibrary (addPersistentHTTPRequestHeader): Value not set. id=%s"), *id);
return;
}
webcom->additionalHeader.Add(id, value);
}
void UWebCommunicationBPLibrary::removePersistentHTTPRequestHeader(FString id) {
if (id.IsEmpty()) {
UE_LOG(LogTemp, Error, TEXT("UWebCommunicationBPLibrary (removePersistentHTTPRequestHeader): Id not set."));
return;
}
webcom->additionalHeader.Remove(id);
}
FString UWebCommunicationBPLibrary::getMimeTypeInternal(FString fileType) {
//fileType = fileType.Replace(TEXT("."), TEXT(""));
if (mimeTypes.Find(fileType) == nullptr) {
return "application/octet-stream";
}
FString mimeType = *mimeTypes.Find(fileType);
if (mimeType.IsEmpty()) {
mimeType = "application/octet-stream";
}
return mimeType;
}
FByteToFileThread* UWebCommunicationBPLibrary::getByteToFileThread(){
if (byteToFileThread == nullptr) {
byteToFileThread = new FByteToFileThread();
}
return byteToFileThread;
}
void UWebCommunicationBPLibrary::startRequests(TArray<struct FhttpRequest>& httpRequests){
for (int32 i = 0; i < httpRequests.Num(); i++) {
UWebCommunicationRequestCompleteObject* requestObject = httpRequests[i].request;
FString url = httpRequests[i].url;
TMap<FString, FString> POSTData = httpRequests[i].POSTData;
EHTTPWebComRequestType requestType = httpRequests[i].requestType;
if (requestObject == nullptr) {
UE_LOG(LogTemp, Error, TEXT("UWebCommunicationBPLibrary: Missing Object instance (153)."));
continue;
}
toCancelRequests.Remove(requestObject->getRequestID());
requestObject->initWebCom();
//requestObject->setWebComHttpRequest(httpRequests[i]);
TSharedRef<IHttpRequest, ESPMode::ThreadSafe> request = FHttpModule::Get().CreateRequest();
request->SetHeader("User-Agent", "UE4 Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.81 Safari/537.36");
switch (requestType) {
case EHTTPWebComRequestType::GET:
fillRequestGET(httpRequests[i], request);
fillHeader(httpRequests[i], request);
if (requestObject->getMultiStepDownload() > 0) {
request->OnProcessRequestComplete().BindUObject(requestObject, &UWebCommunicationRequestCompleteObject::requestMultiStepComplete);
#if ENGINE_MAJOR_VERSION >= 5 & ENGINE_MINOR_VERSION >= 4
request->OnRequestProgress64().BindUObject(requestObject, &UWebCommunicationRequestCompleteObject::requestMultiStepDownload);
#else
request->OnRequestProgress().BindUObject(requestObject, &UWebCommunicationRequestCompleteObject::requestMultiStepDownload);
#endif
request->ProcessRequest();
continue;
}
if ((requestObject->getFileCancelResumeDownloadByteStart() > 0)) {
request->SetHeader("Range", "bytes=" + UWebCommunicationBPLibrary::Int64ToFString(requestObject->getFileCancelResumeDownloadByteStart()) + "-");
}
#if ENGINE_MAJOR_VERSION >= 5 & ENGINE_MINOR_VERSION >= 4
request->OnRequestProgress64().BindUObject(requestObject, &UWebCommunicationRequestCompleteObject::requestProgressDownload);
#else
request->OnRequestProgress().BindUObject(requestObject, &UWebCommunicationRequestCompleteObject::requestProgressDownload);
#endif
break;
case EHTTPWebComRequestType::GETLowRamDownload:
fillRequestGET(httpRequests[i], request);
request->OnProcessRequestComplete().BindUObject(requestObject, &UWebCommunicationRequestCompleteObject::requestCompleteLowRam);
#if ENGINE_MAJOR_VERSION >= 5 & ENGINE_MINOR_VERSION >= 4
request->OnRequestProgress64().BindUObject(requestObject, &UWebCommunicationRequestCompleteObject::requestProgressDownloadLowRam);
#else
request->OnRequestProgress().BindUObject(requestObject, &UWebCommunicationRequestCompleteObject::requestProgressDownloadLowRam);
#endif
if (requestObject->getFileCancelResumeDownloadByteFullSize() == 0) {
//first request is send to ge the file size
request->SetHeader("Range", "bytes=0-0");
}
else {
if ((requestObject->getFileCancelResumeDownloadByteStart() + requestObject->getFileCancelResumeDownloadBytePartSize()) > requestObject->getFileCancelResumeDownloadByteFullSize()) {
request->SetHeader("Range", "bytes=" + UWebCommunicationBPLibrary::Int64ToFString(requestObject->getFileCancelResumeDownloadByteStart()) + "-");
}
else {
request->SetHeader("Range", "bytes=" + UWebCommunicationBPLibrary::Int64ToFString(requestObject->getFileCancelResumeDownloadByteStart()) + "-" + UWebCommunicationBPLibrary::Int64ToFString(requestObject->getFileCancelResumeDownloadByteStart() + requestObject->getFileCancelResumeDownloadBytePartSize()));
}
}
fillHeader(httpRequests[i], request);
//UE_LOG(LogTemp, Error, TEXT("Head: %s"), *request->GetHeader("Range"));
request->ProcessRequest();
continue;
break;
case EHTTPWebComRequestType::PUT:
case EHTTPWebComRequestType::PUT_STREAM_MP:
case EHTTPWebComRequestType::PUT_STREAM_BLANK:
case EHTTPWebComRequestType::PUT_STREAM_COPY:
case EHTTPWebComRequestType::POST_UPLOAD:
fillHeader(httpRequests[i], request);
if (!fillRequestUPLOAD(httpRequests[i], request)) {
continue;
}
#if ENGINE_MAJOR_VERSION >= 5 & ENGINE_MINOR_VERSION >= 4
request->OnRequestProgress64().BindUObject(requestObject, &UWebCommunicationRequestCompleteObject::requestProgressUpload);
#else
request->OnRequestProgress().BindUObject(requestObject, &UWebCommunicationRequestCompleteObject::requestProgressUpload);
#endif
break;
case EHTTPWebComRequestType::POST:
fillRequestPOST(httpRequests[i], request);
#if ENGINE_MAJOR_VERSION >= 5 & ENGINE_MINOR_VERSION >= 4
request->OnRequestProgress64().BindUObject(requestObject, &UWebCommunicationRequestCompleteObject::requestProgressDownload);
#else
request->OnRequestProgress().BindUObject(requestObject, &UWebCommunicationRequestCompleteObject::requestProgressDownload);
#endif
fillHeader(httpRequests[i], request);
break;
case EHTTPWebComRequestType::INDIVIDUAL:
case EHTTPWebComRequestType::INDIVIDUAL_STREAM:
add picoxr plugin
2025-07-29 14:53:32 +08:00
case EHTTPWebComRequestType::INDIVIDUAL_BYTES:
initial commit
2025-03-10 09:43:27 +08:00
request->SetVerb(httpRequests[i].verb);
request->SetURL(url);
add picoxr plugin
2025-07-29 14:53:32 +08:00
switch (requestType) {
case EHTTPWebComRequestType::INDIVIDUAL:
initial commit
2025-03-10 09:43:27 +08:00
request->SetContentAsString(httpRequests[i].content);
add picoxr plugin
2025-07-29 14:53:32 +08:00
break;
case EHTTPWebComRequestType::INDIVIDUAL_STREAM:
initial commit
2025-03-10 09:43:27 +08:00
request->SetContentAsStreamedFile(httpRequests[i].content);
add picoxr plugin
2025-07-29 14:53:32 +08:00
break;
case EHTTPWebComRequestType::INDIVIDUAL_BYTES:
request->SetContent(httpRequests[i].binaryContent);
break;
initial commit
2025-03-10 09:43:27 +08:00
}
fillHeader(httpRequests[i], request);
#if ENGINE_MAJOR_VERSION >= 5 & ENGINE_MINOR_VERSION >= 4
if (httpRequests[i].bindDownloadProgressEvent) {
request->OnRequestProgress64().BindUObject(requestObject, &UWebCommunicationRequestCompleteObject::requestProgressDownload);
}
if (httpRequests[i].bindUploadProgressEvent) {
request->OnRequestProgress64().BindUObject(requestObject, &UWebCommunicationRequestCompleteObject::requestProgressUpload);
}
#else
if (httpRequests[i].bindDownloadProgressEvent) {
request->OnRequestProgress().BindUObject(requestObject, &UWebCommunicationRequestCompleteObject::requestProgressDownload);
}
if (httpRequests[i].bindUploadProgressEvent) {
request->OnRequestProgress().BindUObject(requestObject, &UWebCommunicationRequestCompleteObject::requestProgressUpload);
}
#endif
break;
}
#if ENGINE_MAJOR_VERSION >= 5 & ENGINE_MINOR_VERSION >= 4
if (httpRequests[i].bindServerSendEvent) {
request->OnRequestProgress64().BindUObject(requestObject, &UWebCommunicationRequestCompleteObject::requestProgressServerSendEvent);
}
#else
if (httpRequests[i].bindServerSendEvent) {
request->OnRequestProgress().BindUObject(requestObject, &UWebCommunicationRequestCompleteObject::requestProgressServerSendEvent);
}
#endif
request->OnProcessRequestComplete().BindUObject(requestObject, &UWebCommunicationRequestCompleteObject::requestComplete);
request->ProcessRequest();
startedRequests.Add(requestObject->getRequestID(), request);
}
httpRequests.Empty();
}
void UWebCommunicationBPLibrary::registerUAsyncNodeHttpRequest(FString requestIDP, UAsyncNodeWebCom* asyncNodeHttpRequest){
//UE_LOG(LogTemp, Error, TEXT("registerUAsyncNodeHttpRequest: %s"), *requestIDP);
asyncNodeHttpRequests.Add(requestIDP, asyncNodeHttpRequest);
}
void UWebCommunicationBPLibrary::unregisterUAsyncNodeHttpRequest(FString requestIDP){
//UE_LOG(LogTemp, Error, TEXT("unregisterUAsyncNodeHttpRequest: %s"), *requestIDP);
asyncNodeHttpRequests.Remove(requestIDP);
}
UAsyncNodeWebCom* UWebCommunicationBPLibrary::getUAsyncNodeHttpRequest(FString requestIDP){
//UE_LOG(LogTemp, Error, TEXT("getUAsyncNodeHttpRequest: %s"), *requestIDP);
if (asyncNodeHttpRequests.Find(requestIDP) == nullptr) {
return nullptr;
}
return *asyncNodeHttpRequests.Find(requestIDP);
}
void UWebCommunicationBPLibrary::fireErrorMessageInGameThread(UAsyncNodeWebCom* asyncNodeHttpRequest, int32 errorCode, FString requestID){
AsyncTask(ENamedThreads::GameThread, [asyncNodeHttpRequest, errorCode, requestID]() {
TArray<uint8> byteArray;
TArray<FString> dataArray;
if (asyncNodeHttpRequest != nullptr) {
asyncNodeHttpRequest->httpRequestComplete("", dataArray, dataArray, 400, byteArray, requestID);
}
else {
webcom->onhttpRequestCompleteDelegate.Broadcast("", dataArray, dataArray, 400, byteArray, requestID);
}
});
}
void UWebCommunicationBPLibrary::fillRequestGET(FhttpRequest& requestStruct, TSharedRef<IHttpRequest, ESPMode::ThreadSafe> request){
request->SetHeader("Content-Type", "application/x-www-form-urlencoded");
request->SetVerb("GET");
request->SetURL(requestStruct.url);
}
void UWebCommunicationBPLibrary::fillRequestPOST(FhttpRequest& requestStruct, TSharedRef<IHttpRequest, ESPMode::ThreadSafe> request){
request->SetHeader("Content-Type", "application/x-www-form-urlencoded");
request->SetVerb("POST");
request->SetURL(requestStruct.url);
FString JoinedStr = postMapToString(requestStruct.POSTData);
request->SetContentAsString(JoinedStr);
FTCHARToUTF8 Convert(*JoinedStr);
request->SetHeader("Content-Length", FString::FromInt(Convert.Length()));
}
void UWebCommunicationBPLibrary::fillHeader(FhttpRequest& requestStruct, TSharedRef<IHttpRequest, ESPMode::ThreadSafe> request) {
//persistent header
if (UWebCommunicationBPLibrary::webcom->additionalHeader.Num() > 0) {
for (auto& element : UWebCommunicationBPLibrary::webcom->additionalHeader) {
request->SetHeader(element.Key, element.Value);
}
}
//custom header
if (requestStruct.header.Num() > 0) {
for (auto& element : requestStruct.header) {
request->SetHeader(element.Key, element.Value);
}
}
}
bool UWebCommunicationBPLibrary::fillRequestUPLOAD(FhttpRequest& requestStruct, TSharedRef<IHttpRequest, ESPMode::ThreadSafe> request){
if (requestStruct.requestType == EHTTPWebComRequestType::POST_UPLOAD) {
request->SetVerb("POST");
}
else {
request->SetVerb("PUT");
}
request->SetURL(requestStruct.url);
if (requestStruct.requestType == EHTTPWebComRequestType::POST_UPLOAD || requestStruct.requestType == EHTTPWebComRequestType::PUT) {
FString boundary = "UE4WebCommunicationPlugin_" + FString::FromInt(FDateTime::Now().GetTicks());
request->SetHeader("Content-Type", "multipart/form-data; boundary=----" + boundary);
if (requestStruct.filePath.IsEmpty() == false) {
requestStruct.filePaths.Add(requestStruct.filePath);
}
TArray<uint8> dataToSend;
for (int32 i = 0; i < requestStruct.filePaths.Num(); i++){
FString dir;
if (requestStruct.DirectoryType == EHTTPWebComFileUpload::E_ad) {
dir = FPaths::ConvertRelativePathToFull(requestStruct.filePaths[i]);
}
else {
FString gameDir = FPaths::ProjectDir();
dir = FPaths::ConvertRelativePathToFull(gameDir + requestStruct.filePaths[i]);
}
if (!FPaths::FileExists(dir)) {
UE_LOG(LogTemp, Error, TEXT("UWebCommunicationBPLibrary: File not found: %s"), *dir);
return false;
}
FString fileName = FPaths::GetCleanFilename(dir);
FString fileFormat = FPaths::GetExtension(fileName, false);
FString mimeType = UWebCommunicationBPLibrary::getWebCommunicationTarget()->getMimeTypeInternal(fileFormat);
TArray<uint8> fileData;
if (!FFileHelper::LoadFileToArray(fileData, *dir)) {
UE_LOG(LogTemp, Error, TEXT("UWebCommunicationBPLibrary: Can't read File: %s"), *dir);
return false;
}
FString fileID = requestStruct.fileID;
if (requestStruct.fileIDs.Num() > i) {
fileID = requestStruct.fileIDs[i];
}
//add File
TArray<uint8> fileHeaderArray = fstringToByteArray("\r\n------" + boundary + "\r\nContent-Disposition: form-data; name=\"" + fileID + "\"; filename=\"" + fileName + "\"\r\n" + "Content-Type: " + mimeType + "\r\n\r\n");
dataToSend.Append(fileHeaderArray);
dataToSend.Append(fileData);
fileData.Empty();
}
//add Post Data
if (requestStruct.POSTData.Num() > 0) {
TArray<FString> keys;
requestStruct.POSTData.GetKeys(keys);
for (int i = 0; i < keys.Num(); i++) {
if (requestStruct.POSTData.Find(keys[i]) == nullptr) {
UE_LOG(LogTemp, Warning, TEXT("UWebCommunicationBPLibrary: Parameter %s has no value."), *keys[i]);
continue;
}
FString postVal = "\r\n------" + boundary + "\r\nContent-Disposition: form-data; name=\"" + keys[i] + "\"\r\n\r\n" + *requestStruct.POSTData.Find(keys[i]);
dataToSend.Append(fstringToByteArray(postVal));
}
}
//fill head after file data
TArray<uint8> bottomArray = fstringToByteArray("\r\n------" + boundary + "--\r\n");
dataToSend.Append(bottomArray);
request->SetHeader("Content-Length", FString::FromInt(dataToSend.Num()));
request->SetContent(dataToSend);
//FFileHelper::SaveArrayToFile(dataToSend, *FString("d:/testuploadDebug.txt"));
return true;
}
if (requestStruct.requestType == EHTTPWebComRequestType::PUT_STREAM_MP || requestStruct.requestType == EHTTPWebComRequestType::PUT_STREAM_COPY){
FString dir;
if (requestStruct.DirectoryType == EHTTPWebComFileUpload::E_ad) {
dir = FPaths::ConvertRelativePathToFull(requestStruct.filePath);
}
else {
FString gameDir = FPaths::ProjectDir();
dir = FPaths::ConvertRelativePathToFull(gameDir + requestStruct.filePath);
}
if (!FPaths::FileExists(dir)) {
UE_LOG(LogTemp, Error, TEXT("UWebCommunicationBPLibrary: File not found: %s"), *dir);
return false;
}
FString fileName = FPaths::GetCleanFilename(dir);
FString fileFormat = FPaths::GetExtension(fileName, false);
FString mimeType = UWebCommunicationBPLibrary::getWebCommunicationTarget()->getMimeTypeInternal(fileFormat);
if (requestStruct.requestType == EHTTPWebComRequestType::PUT_STREAM_COPY) {
FString copy = dir.Replace(*FPaths::GetCleanFilename(dir), *(FPaths::GetBaseFilename(dir)+ "_UEUploadCopy_" + FGuid::NewGuid().ToString() + "." + FPaths::GetExtension(dir)));
FPlatformFileManager::Get().GetPlatformFile().CopyFile(*copy,*dir);
dir = copy;
}
if (isFileBlocked(dir)) {
UE_LOG(LogTemp, Error, TEXT("UWebCommunicationBPLibrary: Can't read File. If you tried to upload the same file a few seconds ago, it may still be open. Please wait a few seconds until the file is closed. %s"), *dir);
return false;
}
FArchive* writer = IFileManager::Get().CreateFileWriter(*dir, FILEWRITE_Append);
if (writer == nullptr) {
UE_LOG(LogTemp, Error, TEXT("UWebCommunicationBPLibrary: Can't read File. If you tried to upload the same file a few seconds ago, it may still be open. Please wait a few seconds until the file is closed. %s"), *dir);
return false;
}
FString fileSize = FString::FromInt(writer->TotalSize());
requestStruct.filePath = dir;
requestStruct.originalFileSize = writer->TotalSize();
requestStruct.request->setRequestStruct(requestStruct);
FString boundary = "UE4WebCommunicationPlugin_" + fileSize;
request->SetHeader("Content-Type", "multipart/form-data; boundary=----" + boundary);
FString bodyHeaderFake = "\r\n\r\n------" + boundary + "\r\nContent-Disposition: form-data; name=\"" + requestStruct.fileID + "\"; filename=\"" + fileName + "\"\r\n" + mimeType;
FString bottom = "\r\n------" + boundary + "--\r\n";
//request->SetHeader("Content-Length", FString::FromInt(FPlatformFileManager::Get().GetPlatformFile().FileSize(*dir)));
request->SetHeader("Content-Length", FString::FromInt(writer->TotalSize() +bodyHeaderFake.Len()+ bottom.Len())+bodyHeaderFake);
FTCHARToUTF8 Convert(*bottom);
writer->Serialize((uint8*)Convert.Get(), Convert.Length());
writer->Close();
delete writer;
request->SetContentAsStreamedFile(dir);
return true;
}
if (requestStruct.requestType == EHTTPWebComRequestType::PUT_STREAM_BLANK) {
FString dir;
if (requestStruct.DirectoryType == EHTTPWebComFileUpload::E_ad) {
dir = FPaths::ConvertRelativePathToFull(requestStruct.filePath);
}
else {
FString gameDir = FPaths::ProjectDir();
dir = FPaths::ConvertRelativePathToFull(gameDir + requestStruct.filePath);
}
if (!FPaths::FileExists(dir)) {
UE_LOG(LogTemp, Error, TEXT("UWebCommunicationBPLibrary: File not found: %s"), *dir);
return false;
}
FString fileName = FPaths::GetCleanFilename(dir);
FString fileFormat = FPaths::GetExtension(fileName, false);
FString mimeType = UWebCommunicationBPLibrary::getWebCommunicationTarget()->getMimeTypeInternal(fileFormat);
request->SetHeader("fileid", requestStruct.fileID);
request->SetHeader("filename", fileName);
request->SetHeader("fileformat", fileFormat);
request->SetHeader("mimetype", mimeType);
request->SetContentAsStreamedFile(dir);
return true;
}
return false;
}
TArray<uint8> UWebCommunicationBPLibrary::fstringToByteArray(FString data){
TArray<uint8> byteArray;
FTCHARToUTF8 Convert(*data);
byteArray.Append((uint8*)((ANSICHAR*)Convert.Get()), Convert.Length());
return byteArray;
}
FString UWebCommunicationBPLibrary::postMapToString(TMap<FString, FString> POSTData){
FString JoinedStr;
TArray<FString> keys;
POSTData.GetKeys(keys);
for (int j = 0; j < keys.Num(); j++) {
FString* val = POSTData.Find(keys[j]);
FString param;
if (val != nullptr) {
param = keys[j] + "=" + *val;
}
if (JoinedStr.IsEmpty()) {
JoinedStr = param;
}
else {
JoinedStr += "&" + param;
}
}
return JoinedStr;
}
FString UWebCommunicationBPLibrary::urlEncode(FString urlParameter) {
return FGenericPlatformHttp::UrlEncode(urlParameter);
}
FString UWebCommunicationBPLibrary::urlEncodePure(FString urlParameter) {
return FGenericPlatformHttp::UrlEncode(urlParameter);
}
FString UWebCommunicationBPLibrary::Int64ToFString(int64 Num){
FString string = FString();
const TCHAR* DigitToChar = TEXT("9876543210123456789");
constexpr int64 ZeroDigitIndex = 9;
bool bIsNumberNegative = Num < 0;
const int64 TempBufferSize = 16;
TCHAR TempNum[TempBufferSize];
int64 TempAt = TempBufferSize; // fill the temp string from the top down.
// Convert to string assuming base ten.
do
{
TempNum[--TempAt] = DigitToChar[ZeroDigitIndex + (Num % 10)];
Num /= 10;
} while (Num);
if (bIsNumberNegative)
{
TempNum[--TempAt] = TEXT('-');
}
const TCHAR* CharPtr = TempNum + TempAt;
const int64 NumChars = TempBufferSize - TempAt;
string.Append(CharPtr, NumChars);
return string;
}