onlyoffice

type CSVDialect struct {
	// Comma is the delimiter: ',', ';', '\t' or '|'.
	Comma byte
	// BOM: the file starts with a UTF-8 byte order mark.
	BOM bool
	// CRLF: its lines end in "\r\n" (else "\n").
	CRLF bool
	// UTF8: its bytes are UTF-8 (ASCII included). False for UTF-16 and for a
	// legacy code page.
	UTF8 bool
}

type CSVKept struct {
	// Applied: the cells were kept. False: the bytes are RewriteCSV's.
	Applied bool
	// Why they were not: "empty" (the file on storage has no record),
	// "not_utf8", "too_large", "too_many_records", "too_many_fields" (in one
	// record), "check_failed" (the result did not read back as the save),
	// "panic".
	Why string
	// Panic, when Why is "panic": what panicked and where, for the log. A
	// runtime panic names indexes, never a cell's text.
	Panic string
	// Records written.
	Records int
	// Unchanged records, written from the file's own bytes.
	Unchanged int
	// Restored cells: in a record somebody changed, the cells whose own text
	// was put back over ONLYOFFICE's way of writing it.
	Restored int
	// New records: saved ones with no record of the file behind them.
	New int
	// Deleted records: the file's, with no saved record.
	Deleted int
}

type CallbackPayload struct {
	Key    string `json:"key"`
	Status int    `json:"status"`
	URL    string `json:"url"`
	Token  string `json:"token,omitempty"`
	// FileType is the type of the document at URL ("csv", "xlsx", ...). The
	// server saves in the document's own type by default
	// (`assemblyFormatAsOrigin`), in OOXML when that is off (filex 0.51,
	// callback_csv.go).
	FileType string `json:"filetype,omitempty"`
	// Users are the editors of the session: the user ids the editor config
	// named, filex account ids.
	Users []string `json:"users,omitempty"`
}

type ConfigOption func(*configExtras)

type ConvertError struct {
	// Code is the document server's error number (-1 to -10), 0 when the
	// failure was not its answer (the network, an HTTP error, a timeout).
	Code int
	// Class says what it means (ClassOf, or transient for everything that is
	// not the document server's answer).
	Class ErrorClass
	// HTTPStatus is the status of an answer that was not a conversion answer.
	HTTPStatus int
	// What is the short name a record keeps: "ds-3", "http-502", "net",
	// "timeout", "answer", "origin", "result". Never a URL, never a secret.
	What string
	Err  error
}

type ConvertRequest struct {
	// FetchURL is where the document server downloads the source: filex's
	// signed fetch address for a purpose (PurposeFetchURL).
	FetchURL string
	// FileType is the source's type: its extension, lower case, no dot.
	FileType string
	// OutputType is what to make: "png" for a thumbnail, "pdf", "docx", ...
	OutputType string
	// Title is the file's name, for the document server's log and the
	// result's name.
	Title string
	// Key is the conversion's key (ConvertKey). Required.
	Key string
	// Thumbnail and SpreadsheetLayout are optional.
	Thumbnail         *Thumbnail
	SpreadsheetLayout *SpreadsheetLayout
	// CodePage and Delimiter are the conversion API's CSV and text knobs
	// (`codePage`, `delimiter`); zero leaves them out.
	CodePage  int
	Delimiter int
}

type ConvertResult struct {
	FileURL  string
	FileType string
}

type Converter struct {
	// DocumentServerURL is the document server's base address, as filex is
	// configured with it. Results are only fetched from its origin.
	DocumentServerURL string
	// Secret signs every request; empty sends them unsigned (only the
	// reverse-path probe's JWT question does).
	Secret string
	// HTTP is the client requests go through (nil: a default one without a
	// timeout of its own; the caller's context bounds every request).
	HTTP *http.Client
	// PollFirst and PollMax are the wait before the first poll and the
	// longest wait between two (zero: 200 ms and 1 s).
	PollFirst, PollMax time.Duration
}

type Diagnosis struct {
	Verdict string `json:"verdict"`
	// OpenedAt is when filex last handed out an editor configuration for the
	// document.
	OpenedAt *time.Time `json:"opened_at,omitempty"`
	// Fetch is the last answer filex gave the document server for it.
	Fetch *FetchOutcome `json:"fetch,omitempty"`
	Scope string        `json:"scope"`
}

type EditorConfig struct {
	DocumentServerURL string         `json:"documentServerUrl"`
	Config            map[string]any `json:"config"`
}

type ErrorClass string

type FetchOutcome struct {
	At     time.Time `json:"at"`
	Status int       `json:"status"`
	Code   string    `json:"reason_code,omitempty"`
	Reason string    `json:"reason,omitempty"`
}

type LayoutMargin struct {
	Left   string `json:"left"`
	Right  string `json:"right"`
	Top    string `json:"top"`
	Bottom string `json:"bottom"`
}

type LayoutSize struct {
	Width  string `json:"width"`
	Height string `json:"height"`
}

type PurposeOutcome struct {
	At     time.Time
	Status int
	Code   string
}

type ReverseResult struct {
	// Checked is false when the question could not be put at all — nothing
	// configured, or the document server did not answer. A false here must
	// never be rendered as a failure of the route.
	Checked bool `json:"checked"`
	// OK is true only when the probe request actually ARRIVED at filex and
	// filex served it, the way it serves a document.
	OK bool `json:"ok"`
	// URL is the address the document server was asked to fetch, so an
	// operator reading a red result can try it themselves.
	URL string `json:"url,omitempty"`
	// Code is the document server's own error number when it returned one.
	// -4 is "error while downloading the document file" — the shape of a
	// broken reverse path. 0 means it did not report an error.
	Code int `json:"code,omitempty"`
	// Detail is the sentence to show the operator.
	Detail string `json:"detail,omitempty"`
	// Advice says what to look at first when the document server could not
	// download the probe (one of the Advice* codes). Empty when there is
	// nothing to advise. A client that wants its own wording keys off this,
	// never off Detail.
	Advice string `json:"advice,omitempty"`
	// JWTEnforced answers the second question: did the document server refuse
	// a request that carried no token? true: it enforces JWT. false: it took
	// an unsigned request, so it refuses filex's editor token (it checks it
	// against its own secret) and sends its save callbacks unsigned, which
	// filex refuses. Absent: it could not be told.
	JWTEnforced *bool `json:"jwt_enforced,omitempty"`
}

type Service struct {
	Store           db.Store
	StorageResolver func(int64) (storage.Driver, error)

	// DocumentServerURL / JWTSecret are the BOOT-TIME values (env/YAML). They
	// are the fallback only: when Live is wired the running configuration is
	// read from the `external_services` row on every call, so an operator who
	// configures OnlyOffice in the admin UI does not have to restart filex.
	// See internal/external and issue #17.
	DocumentServerURL string // e.g. https://docs.example.com
	JWTSecret         string // shared secret with the doc server
	// Live, when non-nil, returns the current url + secret. Nil means "use the
	// fields", which is what the unit tests and any no-DB caller want.
	Live      func(ctx context.Context) (url, secret string)
	PublicURL string // filex public base URL — used to build callbacks
	// LiveCallbackURL, when non-nil, returns the address the DOCUMENT SERVER
	// should use to reach filex. Empty result means "the public URL".
	//
	// ⚠ These are two different addresses for two different readers. PublicURL
	// is what a person's browser uses and what every share link is built from;
	// this one is only ever read by the document server's container. They are
	// usually the same string, and on podman or a private network they cannot
	// be — which is why a document opened and its save never came back with
	// nothing in filex's log to show for it (issue #17).
	LiveCallbackURL func(ctx context.Context) string
	FetchTTL        time.Duration

	// Body resolves where a document's bytes are: the driver, or filex's
	// staging area while a staged upload is still transferring. It is the
	// resolver the fetch endpoint serves the document server from, so the
	// callback compares a saved CSV with the bytes the editor was given
	// (callback_csv.go csvOriginal). Nil-safe: it then answers the driver.
	Body *filebody.Resolver

	// Sync is the shared post-write gate every other write surface in filex
	// goes through: it upserts the node row, re-indexes the document,
	// dispatches a thumbnail, tells open explorers, emits the canonical
	// `file.updated` webhook event and schedules the antivirus scan.
	//
	// ⚠ Optional, and its absence degrades gracefully rather than silently:
	// an unwired Service falls back to a Syncer with no search index (see
	// syncer), so a save still announces itself and is still scanned — only
	// the re-index is skipped. Wire it with AttachSync at boot.
	Sync *protocolsync.Syncer
	// contains filtered or unexported fields
}

type SpreadsheetLayout struct {
	IgnorePrintArea bool          `json:"ignorePrintArea"`
	Orientation     string        `json:"orientation,omitempty"`
	FitToWidth      int           `json:"fitToWidth"`
	FitToHeight     int           `json:"fitToHeight"`
	GridLines       bool          `json:"gridLines"`
	Headings        bool          `json:"headings"`
	PageSize        *LayoutSize   `json:"pageSize,omitempty"`
	Margins         *LayoutMargin `json:"margins,omitempty"`
}

type Target struct {
	DocumentServerURL string
	Secret            string
	// CallbackURL is the address the document server is sent to. Empty means
	// filex's public URL, as for a document.
	CallbackURL string
	// Draft marks values that are not the ones in force (the admin page's
	// unsaved form). The probe is verified against them rather than against
	// the saved configuration, which would refuse a candidate secret.
	Draft bool
}

type ThumbRequest struct {
	NodeID    int64
	StorageID int64
	// Name is the file's name; its extension is the type the document server
	// is told.
	Name string
	// ContentSig is the content's fingerprint (what the thumbnail row
	// records): a new version of the file is a new conversion key.
	ContentSig string
	// Attempt counts the tries at this content, from 1: a retry is a new key,
	// so a failure the document server cached is not answered again.
	Attempt int
	// MaxBytes is the largest result accepted (0: 32 MB).
	MaxBytes int64
}

type Thumbnail struct {
	Aspect int  `json:"aspect"`
	First  bool `json:"first"`
	Width  int  `json:"width,omitempty"`
	Height int  `json:"height,omitempty"`
}