officesave

type CSVDialect struct {
	// Comma is the delimiter: ',', ';', '\t' or '|'.
	Comma byte
	// BOM: the file starts with a byte order mark (UTF-8's, or UTF-16's for a
	// UTF-16 file).
	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
	// code page.
	UTF8 bool
	// Encoding is what it is written in when it is not UTF-8: "utf-16le",
	// "utf-16be", or a code page ("windows-1254"), as a browser's TextDecoder
	// names them (encoding.go). Empty for UTF-8, and for a file whose encoding
	// nobody read (a dialect written by hand).
	Encoding string
}

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
	// Commas: cells somebody typed or added, numbers ONLYOFFICE wrote with a
	// decimal point, written with the decimal comma of their column
	// (csvDecimalCommas).
	Commas int
}

type CSVSave struct {
	CSVKept
	// File is how the written file is written: the file's own dialect (its
	// encoding may be another code page that reads the file's bytes alike,
	// one that holds the save's letters: alikePages).
	File CSVDialect
	// Saved is how the editor wrote its save.
	Saved CSVDialect
}

type Declared struct {
	// Delimiter is its one character, 0 when not said.
	Delimiter byte
	// Encoding is its name (EncodingLabel's), "" when not said.
	Encoding string
	// BOM: it starts with a byte order mark; nil when not said.
	BOM *bool
	// EOL is "crlf" or "lf", "" when not said.
	EOL string
}

type Env struct {
	Store  Store
	Driver storage.Driver
	Writer storage.Writer
	// Locks is the storage's lock view from the SHARED resolver (api.Deps.ACL):
	// a fresh acl.New does not know the vaults, and a name inside a vault
	// must be refused here as everywhere.
	Locks writegate.Locks
	// App is the app writing it (an app's own lock lets it through); 0 for the
	// Document Server.
	App int64
	// MayCreate reports whether the person may create a file at rel now
	// (files.create there: role, folder exceptions, grants, a blocked file
	// type, an app's lock).
	MayCreate func(ctx context.Context, uid int64, rel string) bool
	// Sync records the new file in the catalogue; Write emits the one event
	// itself, for the people it was written for, with the notice.
	Sync *protocolsync.Syncer
	// Origin is the event's origin (writehook.OriginOnlyOffice,
	// writehook.OriginPlugin).
	Origin string
}

type GateError struct{ Err error }

type Original struct {
	// Head is its first bytes (CSVSniffBytes at most): how it is written is
	// read from them. nil when nothing of it could be read.
	Head []byte
	// Body is the whole file, nil when it is not held (Why says why).
	Body []byte
	// Why it is not held: "too_large" (over KeepMaxBytes), "unreadable" (the
	// read broke off).
	Why string
}

type Refusal struct {
	// Why:
	//   - "delimiter", "encoding", "bom", "eol": the producer declared it one
	//     way and the bytes are written another (Declared, Found);
	//   - "unreadable": bytes that are not text in an encoding filex can read
	//     for the file (Found);
	//   - "unencodable": the file is in Encoding, which cannot hold Char;
	//   - "package": a spreadsheet package (XLSX, ODS, XLS) where CSV text
	//     belongs.
	Why string
	// Declared and Found, as a person reads them: `;`, `TAB`, `utf-8`,
	// `CRLF`, `yes`/`no` for a byte order mark.
	Declared, Found string
	// Encoding is the file's encoding, for "unencodable".
	Encoding string
	// Char is the first character the file's encoding cannot hold.
	Char rune
}

type Save struct {
	// Target is the name it is written under (Env.BesideTarget,
	// Env.ConflictTarget).
	Target string
	// Format is the type the bytes are in.
	Format string
	Mime   string
	// TitleKey, BodyKey and Vars are what the people it was written for are
	// told (srvtext keys, every built-in language into the notice's meta).
	TitleKey string
	BodyKey  string
	Vars     srvtext.Vars
	// Action is the audit row's action.
	Action string
	// Why is the log line's reason.
	Why string
}

type Store interface {
	GetNodeByPath(ctx context.Context, storageID int64, pathHash string) (*model.Node, error)
	GetStorage(ctx context.Context, id int64) (*model.Storage, error)
	GetUser(ctx context.Context, id int64) (*model.User, error)
	InsertAuditEntry(ctx context.Context, e *model.AuditEntry) error
}

type TextDialect struct {
	// Delimiter is one character: ",", ";", "\t" or "|".
	Delimiter string `json:"delimiter"`
	// BOM: the file starts with a byte order mark.
	BOM bool `json:"bom"`
	// CRLF: its lines end in "\r\n".
	CRLF bool `json:"crlf"`
	// Encoding is its encoding's name as a browser's TextDecoder takes it:
	// "utf-8", "utf-16le", "utf-16be", "windows-1254"...
	Encoding string `json:"encoding"`
}

type Written struct {
	// Node is the new file's catalogue row.
	Node *model.Node
	Size int64
	// For are the people it was written for, the one who may create it first.
	For []int64
}