Based on golang, write a tool to convert word/excel/ppt to pdf

package office

import (
	ole "/go-ole/go-ole"
	"/go-ole/go-ole/oleutil"
	log "/sirupsen/logrus"
)

/// For more content, please refer to the official COM document /zh-cn/office/vba/api/type Operation struct {
	OpType    string
	Arguments []interface{}
}

/// Some applications do not allow hidden, such as ppt, so Visible needs to be settype ConvertHandler struct {
	FileInPath      string
	FileOutPath     string
	ApplicationName string
	WorkspaceName   string
	Visible         bool
	DisplayAlerts   int
	OpenFileOp      Operation
	ExportOp        Operation
	CloseOp         Operation
	QuitOp          Operation
}

type DomConvertObject struct {
	Application *
	Workspace   *
	SingleFile  *
}

func (handler ConvertHandler) Convert() {
	(0)
	defer ()

	("handle open start")
	dom := ()
	("handle open end")
	("handler in file path is " + )
	("handler out file path is " + )

	defer ()
	defer ()
	defer ()

	(dom)
	("handle export end")

	(dom)
	("handle close end")

	(dom)
	("handle quit end")

}
func (handler ConvertHandler) Open() DomConvertObject {
	var dom DomConvertObject
	unknown, err := ()
	if err != nil {
		panic(err)
	}
	 = (ole.IID_IDispatch)

	(, "Visible", )
	(, "DisplayAlerts", )

	 = (, ).ToIDispatch()

	 = (, , ...).ToIDispatch()
	return dom
}

func (handler ConvertHandler) Export(dom DomConvertObject) {
	(, , ...)

}

func (handler ConvertHandler) Close(dom DomConvertObject) {
	if  == "" {
		(, , ...)
	} else {
		(, , ...)
	}
}

func (handler ConvertHandler) Quit(dom DomConvertObject) {
	(, , ...)

package office

func ConvertDoc2Pdf(fileInputPath string, fileOutputPath string) {

	openArgs := []interface{}{fileInputPath}

	/// /zh-cn/office/vba/api/
	exportArgs := []interface{}{fileOutputPath, 17}

	closeArgs := []interface{}{}

	quitArgs := []interface{}{}

	convertHandler := ConvertHandler{
		FileInPath:      fileInputPath,
		FileOutPath:     fileOutputPath,
		ApplicationName: "",
		WorkspaceName:   "Documents",
		Visible:         false,
		DisplayAlerts:   0,
		OpenFileOp: Operation{
			OpType:    "Open",
			Arguments: openArgs,
		},
		ExportOp: Operation{
			OpType:    "ExportAsFixedFormat",
			Arguments: exportArgs,
		},
		CloseOp: Operation{

			OpType:    "Close",
			Arguments: closeArgs,
		},
		QuitOp: Operation{

			OpType:    "Quit",
			Arguments: quitArgs,
		},
	}
	()
}

package web

import (
	"encoding/json"
	"fmt"
	"io"
	"io/ioutil"
	"net/http"
	"net/url"
	"office-convert/office"
	"os"
	"path"
	"path/filepath"
	"runtime/debug"
	"strconv"

	log "/sirupsen/logrus"
)

const PORT = 10000
const SAVED_DIR = "files"

type ConvertRequestInfo struct {
	FileInUrl  string `json:"file_in_url"`
	SourceType string `json:"source_type"`
	TargetType string `json:"target_type"`
}

func logStackTrace(err ...interface{}) {
	(err)
	stack := string(())
	(stack)
}

func convertHandler(w , r *) {
	defer func() {
		if r := recover(); r != nil {
			(503)
			(w, r)
			logStackTrace(r)
		}
	}()
	if  != "POST" {
		(400)
		(w, "Method not support")
		return
	}

	var convertRequestInfo ConvertRequestInfo
	reqBody, err := ()
	if err != nil {
		(err)
	}
	(reqBody, &convertRequestInfo)

	(convertRequestInfo)
	()

	downloadFile()

	fileOutAbsPath := getFileOutAbsPath(, )
	convert(convertRequestInfo)

	()
	().Set("Content-Type", "application/octet-stream")
	//If the file is too large, consider using it for streaming copy	outFileBytes, err := (fileOutAbsPath)
	if err != nil {
		panic(err)
	}
	(outFileBytes)

}

func convert(convertRequestInfo ConvertRequestInfo) {

	fileOutAbsPath := getFileOutAbsPath(, )
	switch  {
	case "doc", "docx":
		office.ConvertDoc2Pdf(getFileInAbsPath(), fileOutAbsPath)
		break
	case "xls", "xlsx":
		office.ConvertXsl2Pdf(getFileInAbsPath(), fileOutAbsPath)
		break
	case "ppt", "pptx":
		office.ConvertPPT2Pdf(getFileInAbsPath(), fileOutAbsPath)
		break
	}
}

func getNameFromUrl(inputUrl string) string {
	u, err := (inputUrl)
	if err != nil {
		panic(err)
	}
	return ()
}

func getCurrentWorkDirectory() string {
	cwd, err := ()
	if err != nil {
		panic(err)
	}
	return cwd
}

func getFileInAbsPath(url string) string {
	fileName := getNameFromUrl(url)
	currentWorkDirectory := getCurrentWorkDirectory()
	absPath := (currentWorkDirectory, SAVED_DIR, fileName)
	return absPath
}

func getFileOutAbsPath(fileInUrl string, targetType string) string {
	return getFileInAbsPath(fileInUrl) + "." + targetType
}

func downloadFile(url string) {
	("Start download file url :", url)
	resp, err := (url)
	if err != nil {
		panic(err)
	}
	defer ()

	fileInAbsPath := getFileInAbsPath(url)
	dir := (fileInAbsPath)
	// ("dir is " + dir)
	if _, err := (dir); (err) {
		("dir is not exists")
		(dir, 0644)
	}
	out, err := (fileInAbsPath)
	("save file to " + fileInAbsPath)
	if err != nil {
		panic(err)
	}

	defer ()

	_, err = (out, )
	if err != nil {
		panic(err)
	}

	("Download file end url :", url)
}

func StartServer() {

	("start service ...")
	("/convert", convertHandler)
	("127.0.0.1:"+(PORT), nil)
}

server {
        listen       80;
        server_name  ;

        #charset koi8-r;

        #access_log  logs/  main;

        location / {
            root   html;
            index   ;
            proxy_pass http://127.0.0.1:10000;
        }
        # ...Other settings}

{
    "file_in_url":"https://your_docx_file_url",
    "source_type":"docx",
    "target_type":"pdf"
}