package api // import "github.com/SevereCloud/vksdk/v2/api" import ( "bytes" "encoding/json" "io" "io/ioutil" "mime/multipart" "github.com/SevereCloud/vksdk/v2/object" ) // UploadFile uploading file. func (vk *VK) UploadFile(url string, file io.Reader, fieldname, filename string) (bodyContent []byte, err error) { body := new(bytes.Buffer) writer := multipart.NewWriter(body) part, err := writer.CreateFormFile(fieldname, filename) if err != nil { return } _, err = io.Copy(part, file) if err != nil { return } contentType := writer.FormDataContentType() _ = writer.Close() resp, err := vk.Client.Post(url, contentType, body) if err != nil { return } defer resp.Body.Close() bodyContent, err = ioutil.ReadAll(resp.Body) return } // uploadPhoto uploading Photos into Album. // // Supported formats: JPG, PNG, GIF. // // Limits: width+height not more than 14000 px, file size up to 50 Mb, // aspect ratio of at least 1:20. func (vk *VK) uploadPhoto(params Params, file io.Reader) (response PhotosSaveResponse, err error) { uploadServer, err := vk.PhotosGetUploadServer(params) if err != nil { return } bodyContent, err := vk.UploadFile(uploadServer.UploadURL, file, "file1", "file1.jpeg") if err != nil { return } var handler object.PhotosPhotoUploadResponse err = json.Unmarshal(bodyContent, &handler) if err != nil { return } response, err = vk.PhotosSave(Params{ "server": handler.Server, "photos_list": handler.PhotosList, "aid": handler.AID, "hash": handler.Hash, "album_id": params["album_id"], "group_id": params["group_id"], }) return } // UploadPhoto uploading Photos into User Album. // // Supported formats: JPG, PNG, GIF. // // Limits: width+height not more than 14000 px, file size up to 50 Mb, // aspect ratio of at least 1:20. func (vk *VK) UploadPhoto(albumID int, file io.Reader) (response PhotosSaveResponse, err error) { response, err = vk.uploadPhoto(Params{ "album_id": albumID, }, file) return } // UploadPhotoGroup uploading Photos into Group Album. // // Supported formats: JPG, PNG, GIF. // // Limits: width+height not more than 14000 px, file size up to 50 Mb, // aspect ratio of at least 1:20. func (vk *VK) UploadPhotoGroup(groupID, albumID int, file io.Reader) (response PhotosSaveResponse, err error) { response, err = vk.uploadPhoto(Params{ "album_id": albumID, "group_id": groupID, }, file) return } // uploadWallPhoto uploading Photos on Wall. // // Supported formats: JPG, PNG, GIF. // // Limits: width+height not more than 14000 px, file size up to 50 Mb, // aspect ratio of at least 1:20. func (vk *VK) uploadWallPhoto(params Params, file io.Reader) (response PhotosSaveWallPhotoResponse, err error) { uploadServer, err := vk.PhotosGetWallUploadServer(params) if err != nil { return } bodyContent, err := vk.UploadFile(uploadServer.UploadURL, file, "photo", "photo.jpeg") if err != nil { return } var handler object.PhotosWallUploadResponse err = json.Unmarshal(bodyContent, &handler) if err != nil { return } response, err = vk.PhotosSaveWallPhoto(Params{ "server": handler.Server, "photo": handler.Photo, "hash": handler.Hash, "group_id": params["group_id"], }) return } // UploadWallPhoto uploading Photos on User Wall. // // Supported formats: JPG, PNG, GIF. // // Limits: width+height not more than 14000 px, file size up to 50 Mb, // aspect ratio of at least 1:20. func (vk *VK) UploadWallPhoto(file io.Reader) (response PhotosSaveWallPhotoResponse, err error) { response, err = vk.uploadWallPhoto(Params{}, file) return } // UploadGroupWallPhoto uploading Photos on Group Wall. // // Supported formats: JPG, PNG, GIF. // // Limits: width+height not more than 14000 px, file size up to 50 Mb, // aspect ratio of at least 1:20. func (vk *VK) UploadGroupWallPhoto(groupID int, file io.Reader) (response PhotosSaveWallPhotoResponse, err error) { response, err = vk.uploadWallPhoto(Params{ "group_id": groupID, }, file) return } // uploadOwnerPhoto uploading Photos into User Profile or Community // To upload a photo to a community send its negative id in the owner_id parameter. // // Following parameters can be sent in addition: // squareCrop in x,y,w (no quotes) format where x and y are the coordinates of // the preview upper-right corner and w is square side length. // That will create a square preview for a photo. // // Supported formats: JPG, PNG, GIF. // // Limits: size not less than 200x200px, aspect ratio from 0.25 to 3, // width+height not more than 14000 px, file size up to 50 Mb. func (vk *VK) uploadOwnerPhoto(params Params, squareCrop string, file io.Reader) ( response PhotosSaveOwnerPhotoResponse, err error, ) { uploadServer, err := vk.PhotosGetOwnerPhotoUploadServer(params) if err != nil { return } body := new(bytes.Buffer) writer := multipart.NewWriter(body) part, err := writer.CreateFormFile("photo", "photo.jpeg") if err != nil { return } _, err = io.Copy(part, file) if err != nil { return } contentType := writer.FormDataContentType() if squareCrop != "" { err = writer.WriteField("_square_crop", squareCrop) if err != nil { return } } _ = writer.Close() resp, err := vk.Client.Post(uploadServer.UploadURL, contentType, body) if err != nil { return } defer resp.Body.Close() bodyContent, err := ioutil.ReadAll(resp.Body) if err != nil { return } var handler object.PhotosOwnerUploadResponse err = json.Unmarshal(bodyContent, &handler) if err != nil { return } response, err = vk.PhotosSaveOwnerPhoto(Params{ "server": handler.Server, "photo": handler.Photo, "hash": handler.Hash, }) return response, err } // UploadUserPhoto uploading Photos into User Profile. // // Supported formats: JPG, PNG, GIF. // // Limits: size not less than 200x200px, aspect ratio from 0.25 to 3, // width+height not more than 14000 px, file size up to 50 Mb. func (vk *VK) UploadUserPhoto(file io.Reader) (response PhotosSaveOwnerPhotoResponse, err error) { response, err = vk.uploadOwnerPhoto(Params{}, "", file) return } // UploadOwnerPhoto uploading Photos into User Profile or Community // To upload a photo to a community send its negative id in the owner_id parameter. // // Following parameters can be sent in addition: // squareCrop in x,y,w (no quotes) format where x and y are the coordinates of // the preview upper-right corner and w is square side length. // That will create a square preview for a photo. // // Supported formats: JPG, PNG, GIF. // // Limits: size not less than 200x200px, aspect ratio from 0.25 to 3, // width+height not more than 14000 px, file size up to 50 Mb. func (vk *VK) UploadOwnerPhoto(ownerID int, squareCrop string, file io.Reader) ( response PhotosSaveOwnerPhotoResponse, err error, ) { response, err = vk.uploadOwnerPhoto(Params{ "owner_id": ownerID, }, squareCrop, file) return } // UploadMessagesPhoto uploading Photos into a Private Message. // // Supported formats: JPG, PNG, GIF. // // Limits: width+height not more than 14000 px, file size up to 50 Mb, // aspect ratio of at least 1:20. func (vk *VK) UploadMessagesPhoto(peerID int, file io.Reader) (response PhotosSaveMessagesPhotoResponse, err error) { uploadServer, err := vk.PhotosGetMessagesUploadServer(Params{ "peer_id": peerID, }) if err != nil { return } bodyContent, err := vk.UploadFile(uploadServer.UploadURL, file, "photo", "photo.jpeg") if err != nil { return } var handler object.PhotosMessageUploadResponse err = json.Unmarshal(bodyContent, &handler) if err != nil { return } response, err = vk.PhotosSaveMessagesPhoto(Params{ "server": handler.Server, "photo": handler.Photo, "hash": handler.Hash, }) return } // uploadChatPhoto uploading a Main Photo to a Group Chat. // // Supported formats: JPG, PNG, GIF. // // Limits: size not less than 200x200px, // width+height not more than 14000 px, file size up to 50 Mb, // aspect ratio of at least 1:20. func (vk *VK) uploadChatPhoto(params Params, file io.Reader) (response MessagesSetChatPhotoResponse, err error) { uploadServer, err := vk.PhotosGetChatUploadServer(params) if err != nil { return } bodyContent, err := vk.UploadFile(uploadServer.UploadURL, file, "file", "photo.jpeg") if err != nil { return } var handler object.PhotosChatUploadResponse err = json.Unmarshal(bodyContent, &handler) if err != nil { return } response, err = vk.MessagesSetChatPhoto(Params{ "file": handler.Response, }) return } // UploadChatPhoto uploading a Main Photo to a Group Chat without crop. // // Supported formats: JPG, PNG, GIF. // // Limits: size not less than 200x200px, // width+height not more than 14000 px, file size up to 50 Mb, // aspect ratio of at least 1:20. func (vk *VK) UploadChatPhoto(chatID int, file io.Reader) (response MessagesSetChatPhotoResponse, err error) { response, err = vk.uploadChatPhoto(Params{ "chat_id": chatID, }, file) return } // UploadChatPhotoCrop uploading a Main Photo to a Group Chat with crop. // // Supported formats: JPG, PNG, GIF. // // Limits: size not less than 200x200px, // width+height not more than 14000 px, file size up to 50 Mb, // aspect ratio of at least 1:20. func (vk *VK) UploadChatPhotoCrop(chatID, cropX, cropY, cropWidth int, file io.Reader) ( response MessagesSetChatPhotoResponse, err error, ) { response, err = vk.uploadChatPhoto(Params{ "chat_id": chatID, "crop_x": cropX, "crop_y": cropY, "crop_width": cropWidth, }, file) return } // uploadMarketPhoto uploading a Market Item Photo. // // Supported formats: JPG, PNG, GIF. // // Limits: size not less than 400x400px, // width+height not more than 14000 px, file size up to 50 Mb, // aspect ratio of at least 1:20. func (vk *VK) uploadMarketPhoto(params Params, file io.Reader) (response PhotosSaveMarketPhotoResponse, err error) { uploadServer, err := vk.PhotosGetMarketUploadServer(params) if err != nil { return } bodyContent, err := vk.UploadFile(uploadServer.UploadURL, file, "file", "photo.jpeg") if err != nil { return } var handler object.PhotosMarketUploadResponse err = json.Unmarshal(bodyContent, &handler) if err != nil { return } response, err = vk.PhotosSaveMarketPhoto(Params{ "group_id": params["group_id"], "server": handler.Server, "photo": handler.Photo, "hash": handler.Hash, "crop_data": handler.CropData, "crop_hash": handler.CropHash, }) return } // UploadMarketPhoto uploading a Market Item Photo without crop. // // Supported formats: JPG, PNG, GIF. // // Limits: size not less than 400x400px, // width+height not more than 14000 px, file size up to 50 Mb, // aspect ratio of at least 1:20. func (vk *VK) UploadMarketPhoto(groupID int, mainPhoto bool, file io.Reader) ( response PhotosSaveMarketPhotoResponse, err error, ) { response, err = vk.uploadMarketPhoto(Params{ "group_id": groupID, "main_photo": mainPhoto, }, file) return } // UploadMarketPhotoCrop uploading a Market Item Photo with crop. // // Supported formats: JPG, PNG, GIF. // // Limits: size not less than 400x400px, // width+height not more than 14000 px, file size up to 50 Mb, // aspect ratio of at least 1:20. func (vk *VK) UploadMarketPhotoCrop(groupID, cropX, cropY, cropWidth int, file io.Reader) ( response PhotosSaveMarketPhotoResponse, err error, ) { response, err = vk.uploadMarketPhoto(Params{ "group_id": groupID, "main_photo": true, "crop_x": cropX, "crop_y": cropY, "crop_width": cropWidth, }, file) return } // UploadMarketAlbumPhoto uploading a Main Photo to a Group Chat. // // Supported formats: JPG, PNG, GIF. // // Limits: size not less than 1280x720px, // width+height not more than 14000 px, file size up to 50 Mb, // aspect ratio of at least 1:20. func (vk *VK) UploadMarketAlbumPhoto(groupID int, file io.Reader) ( response PhotosSaveMarketAlbumPhotoResponse, err error, ) { uploadServer, err := vk.PhotosGetMarketAlbumUploadServer(Params{ "group_id": groupID, }) if err != nil { return } bodyContent, err := vk.UploadFile(uploadServer.UploadURL, file, "file", "photo.jpeg") if err != nil { return } var handler object.PhotosMarketAlbumUploadResponse err = json.Unmarshal(bodyContent, &handler) if err != nil { return } return vk.PhotosSaveMarketAlbumPhoto(Params{ "group_id": groupID, "server": handler.Server, "photo": handler.Photo, "hash": handler.Hash, }) } // UploadVideo uploading Video Files. // // Supported formats: AVI, MP4, 3GP, MPEG, MOV, FLV, WMV. func (vk *VK) UploadVideo(params Params, file io.Reader) (response VideoSaveResponse, err error) { response, err = vk.VideoSave(params) if err != nil { return } bodyContent, err := vk.UploadFile(response.UploadURL, file, "video_file", "video.mp4") if err != nil { return } var videoUploadError UploadError err = json.Unmarshal(bodyContent, &videoUploadError) if err != nil { return } if videoUploadError.Code != 0 { err = &videoUploadError } return } // uploadDoc uploading Documents. // // Supported formats: any formats excepting mp3 and executable files. // // Limits: file size up to 200 MB. func (vk *VK) uploadDoc(url, title, tags string, file io.Reader) (response DocsSaveResponse, err error) { bodyContent, err := vk.UploadFile(url, file, "file", title) if err != nil { return } var docUploadError UploadError err = json.Unmarshal(bodyContent, &docUploadError) if err != nil { return } if docUploadError.Err != "" { err = &docUploadError return } var handler object.DocsDocUploadResponse err = json.Unmarshal(bodyContent, &handler) if err != nil { return } response, err = vk.DocsSave(Params{ "file": handler.File, "title": title, "tags": tags, }) return response, err } // UploadDoc uploading Documents. // // Supported formats: any formats excepting mp3 and executable files. // // Limits: file size up to 200 MB. func (vk *VK) UploadDoc(title, tags string, file io.Reader) (response DocsSaveResponse, err error) { uploadServer, err := vk.DocsGetUploadServer(nil) if err != nil { return } response, err = vk.uploadDoc(uploadServer.UploadURL, title, tags, file) return } // UploadGroupDoc uploading Documents into Community. // // Supported formats: any formats excepting mp3 and executable files. // // Limits: file size up to 200 MB. func (vk *VK) UploadGroupDoc(groupID int, title, tags string, file io.Reader) (response DocsSaveResponse, err error) { uploadServer, err := vk.DocsGetUploadServer(Params{ "group_id": groupID, }) if err != nil { return } response, err = vk.uploadDoc(uploadServer.UploadURL, title, tags, file) return } // UploadWallDoc uploading Documents on Wall. // // Supported formats: any formats excepting mp3 and executable files. // // Limits: file size up to 200 MB. func (vk *VK) UploadWallDoc(title, tags string, file io.Reader) (response DocsSaveResponse, err error) { uploadServer, err := vk.DocsGetWallUploadServer(nil) if err != nil { return } response, err = vk.uploadDoc(uploadServer.UploadURL, title, tags, file) return } // UploadGroupWallDoc uploading Documents on Group Wall. // // Supported formats: any formats excepting mp3 and executable files. // // Limits: file size up to 200 MB. func (vk *VK) UploadGroupWallDoc(groupID int, title, tags string, file io.Reader) ( response DocsSaveResponse, err error, ) { uploadServer, err := vk.DocsGetWallUploadServer(Params{ "group_id": groupID, }) if err != nil { return } response, err = vk.uploadDoc(uploadServer.UploadURL, title, tags, file) return } // UploadMessagesDoc uploading Documents into a Private Message. // // Supported formats: any formats excepting mp3 and executable files. // // Limits: file size up to 200 MB. func (vk *VK) UploadMessagesDoc(peerID int, typeDoc, title, tags string, file io.Reader) ( response DocsSaveResponse, err error, ) { uploadServer, err := vk.DocsGetMessagesUploadServer(Params{ "peer_id": peerID, "type": typeDoc, }) if err != nil { return } response, err = vk.uploadDoc(uploadServer.UploadURL, title, tags, file) return } // UploadOwnerCoverPhoto uploading a Main Photo to a Group Chat. // // Supported formats: JPG, PNG, GIF. // // Limits: minimum photo size 795x200px, width+height not more than 14000px, // file size up to 50 MB. Recommended size: 1590x400px. func (vk *VK) UploadOwnerCoverPhoto(groupID, cropX, cropY, cropX2, cropY2 int, file io.Reader) ( response PhotosSaveOwnerCoverPhotoResponse, err error, ) { uploadServer, err := vk.PhotosGetOwnerCoverPhotoUploadServer(Params{ "group_id": groupID, "crop_x": cropX, "crop_y": cropY, "crop_x2": cropX2, "crop_y2": cropY2, }) if err != nil { return } bodyContent, err := vk.UploadFile(uploadServer.UploadURL, file, "photo", "photo.jpeg") if err != nil { return } var handler object.PhotosOwnerUploadResponse err = json.Unmarshal(bodyContent, &handler) if err != nil { return } return vk.PhotosSaveOwnerCoverPhoto(Params{ "photo": handler.Photo, "hash": handler.Hash, }) } // UploadStories struct. type UploadStories struct { UploadResult string `json:"upload_result"` Sig string `json:"_sig"` } type rawUploadStoriesPhoto struct { Response UploadStories `json:"response"` Error struct { ErrorCode int `json:"error_code"` Type string `json:"type"` } `json:"error"` } type rawUploadStoriesVideo struct { Response UploadStories `json:"response"` UploadError } // UploadStoriesPhoto uploading Story. // // Supported formats: JPG, PNG, GIF. // Limits: sum of with and height no more than 14000px, file size no // more than 10 MB. Video format: h264 video, aac audio, // maximum 720х1280, 30fps. // // https://vk.com/dev/stories.getPhotoUploadServer func (vk *VK) UploadStoriesPhoto(params Params, file io.Reader) (response StoriesSaveResponse, err error) { uploadServer, err := vk.StoriesGetPhotoUploadServer(params) if err != nil { return } bodyContent, err := vk.UploadFile(uploadServer.UploadURL, file, "file", "file.jpeg") if err != nil { return } var handler rawUploadStoriesPhoto err = json.Unmarshal(bodyContent, &handler) if err != nil { return } if handler.Error.ErrorCode != 0 { err = &UploadError{ Code: handler.Error.ErrorCode, Err: handler.Error.Type, } return response, err } response, err = vk.StoriesSave(Params{ "upload_results": handler.Response.UploadResult, }) return response, err } // UploadStoriesVideo uploading Story. // // Video format: h264 video, aac audio, maximum 720х1280, 30fps. func (vk *VK) UploadStoriesVideo(params Params, file io.Reader) (response StoriesSaveResponse, err error) { uploadServer, err := vk.StoriesGetVideoUploadServer(params) if err != nil { return } bodyContent, err := vk.UploadFile(uploadServer.UploadURL, file, "video_file", "video.mp4") if err != nil { return } var handler rawUploadStoriesVideo err = json.Unmarshal(bodyContent, &handler) if err != nil { return } if handler.UploadError.Code != 0 { return response, &handler.UploadError } response, err = vk.StoriesSave(Params{ "upload_results": handler.Response.UploadResult, }) return response, err } // uploadPollsPhoto uploading a Poll Photo. // // Supported formats: JPG, PNG, GIF. // // Limits: minimum photo size 795x200px, width+height not more than 14000px, // file size up to 50 MB. Recommended size: 1590x400px. func (vk *VK) uploadPollsPhoto(params Params, file io.Reader) (response PollsSavePhotoResponse, err error) { uploadServer, err := vk.PollsGetPhotoUploadServer(params) if err != nil { return } bodyContent, err := vk.UploadFile(uploadServer.UploadURL, file, "photo", "photo.jpeg") if err != nil { return } var handler object.PollsPhotoUploadResponse err = json.Unmarshal(bodyContent, &handler) if err != nil { return } response, err = vk.PollsSavePhoto(Params{ "photo": handler.Photo, "hash": handler.Hash, }) return } // UploadPollsPhoto uploading a Poll Photo. // // Supported formats: JPG, PNG, GIF. // // Limits: minimum photo size 795x200px, width+height not more than 14000px, // file size up to 50 MB. Recommended size: 1590x400px. func (vk *VK) UploadPollsPhoto(file io.Reader) (response PollsSavePhotoResponse, err error) { return vk.uploadPollsPhoto(Params{}, file) } // UploadOwnerPollsPhoto uploading a Poll Photo. // // Supported formats: JPG, PNG, GIF. // // Limits: minimum photo size 795x200px, width+height not more than 14000px, // file size up to 50 MB. Recommended size: 1590x400px. func (vk *VK) UploadOwnerPollsPhoto(ownerID int, file io.Reader) (response PollsSavePhotoResponse, err error) { return vk.uploadPollsPhoto(Params{"owner_id": ownerID}, file) } type uploadPrettyCardsPhotoHandler struct { Photo string `json:"photo"` ErrCode int `json:"errcode"` } // UploadPrettyCardsPhoto uploading a Pretty Card Photo. // // Supported formats: JPG, PNG, GIF. func (vk *VK) UploadPrettyCardsPhoto(file io.Reader) (response string, err error) { uploadURL, err := vk.PrettyCardsGetUploadURL(nil) if err != nil { return } bodyContent, err := vk.UploadFile(uploadURL, file, "file", "photo.jpg") if err != nil { return } var handler uploadPrettyCardsPhotoHandler err = json.Unmarshal(bodyContent, &handler) if err != nil { return } response = handler.Photo if handler.ErrCode != 0 { err = &UploadError{Code: handler.ErrCode} } return } type uploadLeadFormsPhotoHandler struct { Photo string `json:"photo"` ErrCode int `json:"errcode"` } // UploadLeadFormsPhoto uploading a Pretty Card Photo. // // Supported formats: JPG, PNG, GIF. func (vk *VK) UploadLeadFormsPhoto(file io.Reader) (response string, err error) { uploadURL, err := vk.LeadFormsGetUploadURL(nil) if err != nil { return } bodyContent, err := vk.UploadFile(uploadURL, file, "file", "photo.jpg") if err != nil { return } var handler uploadLeadFormsPhotoHandler err = json.Unmarshal(bodyContent, &handler) if err != nil { return } response = handler.Photo if handler.ErrCode != 0 { err = &UploadError{Code: handler.ErrCode} } return } // UploadAppImage uploading a Image into App collection for community app widgets. func (vk *VK) UploadAppImage(imageType string, file io.Reader) (response object.AppWidgetsImage, err error) { uploadServer, err := vk.AppWidgetsGetAppImageUploadServer(Params{ "image_type": imageType, }) if err != nil { return } bodyContent, err := vk.UploadFile(uploadServer.UploadURL, file, "image", "photo.jpeg") if err != nil { return } var handler object.AppWidgetsAppImageUploadResponse err = json.Unmarshal(bodyContent, &handler) if err != nil { return } response, err = vk.AppWidgetsSaveAppImage(Params{ "image": handler.Image, "hash": handler.Hash, }) return } // UploadGroupImage uploading a Image into Community collection for community app widgets. func (vk *VK) UploadGroupImage(imageType string, file io.Reader) (response object.AppWidgetsImage, err error) { uploadServer, err := vk.AppWidgetsGetGroupImageUploadServer(Params{ "image_type": imageType, }) if err != nil { return } bodyContent, err := vk.UploadFile(uploadServer.UploadURL, file, "image", "photo.jpeg") if err != nil { return } var handler object.AppWidgetsGroupImageUploadResponse err = json.Unmarshal(bodyContent, &handler) if err != nil { return } response, err = vk.AppWidgetsSaveGroupImage(Params{ "image": handler.Image, "hash": handler.Hash, }) return } // UploadMarusiaPicture uploading picture. // // Limits: height not more than 600 px, // aspect ratio of at least 2:1. func (vk *VK) UploadMarusiaPicture(file io.Reader) (response MarusiaSavePictureResponse, err error) { uploadServer, err := vk.MarusiaGetPictureUploadLink(nil) if err != nil { return } bodyContent, err := vk.UploadFile(uploadServer.PictureUploadLink, file, "photo", "photo.jpg") if err != nil { return } var handler object.MarusiaPictureUploadResponse err = json.Unmarshal(bodyContent, &handler) if err != nil { return } photo, _ := json.Marshal(handler.Photo) response, err = vk.MarusiaSavePicture(Params{ "server": handler.Server, "photo": string(photo), "hash": handler.Hash, }) return } // UploadMarusiaAudio uploading audio. // // https://vk.com/dev/marusia_skill_docs10 func (vk *VK) UploadMarusiaAudio(file io.Reader) (response MarusiaCreateAudioResponse, err error) { uploadServer, err := vk.MarusiaGetAudioUploadLink(nil) if err != nil { return } bodyContent, err := vk.UploadFile(uploadServer.AudioUploadLink, file, "file", "audio.mp3") if err != nil { return } response, err = vk.MarusiaCreateAudio(Params{ "audio_meta": string(bodyContent), }) return }