Utilizzo dell'archiviazione GridJs

Lavorare con lo storage GridJs

il processo di file generale

Dopo aver importato un file di foglio di calcolo,

GridJs creerà un file di cache con l’uid specificato nel file**Config.FileCacheDirectory** cartella ,

con il formato diAspose.Cells.SaveFormat.Xlsx ,

GridJs salverà anche tutte le forme/immagini in un file di archivio zip nel formato**Config.DirectoryPictureCache** cartella per visualizzare successivamente forme/immagini nell’interfaccia utente del client.

e dopo ogni operazione di aggiornamento nell’interfaccia utente del client,

ad esempio imposta il valore della cella, imposta lo stile della cella, ecc. ,

GridJs lato client js attiverà l’azione del controller per eseguire un’operazione UpdateCell.

In questa azione si verificherà un salvataggio nel file di cache durante il metodo UpdateCell.

        // post: /GridJs/UpdateCell
        [HttpPost] 
        public ActionResult UpdateCell( )
        {
            string p = HttpContext.Request.Form["p"];
            string uid = HttpContext.Request.Form["uid"];
            GridJsWorkbook gwb = new GridJsWorkbook();
            String ret = gwb.UpdateCell(p, uid);
            return Content(ret, "text/plain", System.Text.Encoding.UTF8);
        }

dov’è effettivamente il file di cache

R. Se implementiamo GridCacheForStream e impostiamo GridJsWorkbook.CacheImp. ad esempio nel codice seguente possiamo semplicemente inserire e ottenere il file della cache da**“D:\temp”**

Config.FileCacheDirectory=@"D:\temp";
GridJsWorkbook.CacheImp=new LocalFileCache();
public class LocalFileCache  : GridCacheForStream
    {
         
        /// <summary>
        /// Implement this method to savecache,save the stream to the cache object with the key id.
        /// </summary>
        /// <param name="s">the source stream </param>
        /// <param name="uid">the key id.</param>
        public override void SaveStream(Stream s, String uid)
        {//make sure the directory exist
            String filepath = Path.Combine(Config.FileCacheDirectory, uid);
            using (FileStream fs = new FileStream(filepath, FileMode.Create)) 
            {
                s.Position = 0;
                s.CopyTo(fs);
            }

        }

        /// <summary>
        /// Implement this method to loadcache with the key uid,return the stream from the cache object.
        /// </summary>
        /// <param name="uid">the key id</param>
        /// <returns>the stream from  the cache</returns>
        public override Stream LoadStream(String uid)
        {//make sure the directory is exist
            String filepath = Path.Combine(Config.FileCacheDirectory, uid);;
            FileStream fs = new FileStream(filepath, FileMode.Open);
            return fs;
        }
		...

B.Se non impostiamo GridJsWorkbook.CacheImp,

GridJs creerà e salverà il file all’interno del file**Config.FileCacheDirectory** , che è la directory della cache predefinita che possiamo impostare.

come ottenere il file dei risultati aggiornato

1. un uid specificato per il file

Assicurati una corrispondenza di mappatura specificata tra il file e l’uid,

puoi sempre ottenere lo stesso uid per un nome file specificato, non dalla generazione casuale.

Ad esempio, basta usare il nome del file è ok.

//in controller  
...
        public ActionResult Uidtml(String filename)
        {
 
            return Redirect("~/xspread/uidload.html?file=" + filename + "&uid=" +  Path.GetFileNameWithoutExtension(filename));
        }
 ...
        public ActionResult DetailFileJsonWithUid(string filename,string uid)
        {
            String file = Path.Combine(TestConfig.ListDir, filename);
            GridJsWorkbook wbj = new GridJsWorkbook();
            //check if already in cache
           StringBuilder sb= wbj.GetJsonByUid(uid, filename);
            if(sb==null)
            {
                Workbook wb = new Workbook(file);
                wbj.ImportExcelFile(uid, wb);
                sb = wbj.ExportToJsonStringBuilder(filename);
            }

            return Content(sb.ToString(), "text/plain", System.Text.Encoding.UTF8);
        }

2. sincronizzazione con l’operazione dell’interfaccia utente del client

In realtà per alcune operazioni dell’interfaccia utente del client,

Per esempio:

cambia il foglio attivo con un altro,

cambiare la posizione dell’immagine,

ruotare/ridimensionare l’immagine, ecc.

l’azione UpdateCell non verrà attivata.

Pertanto, se vogliamo ottenere il file aggiornato proprio come mostra l’interfaccia utente del client,

dobbiamo eseguire un’operazione di unione prima di salvare l’azione per sincronizzare l’operazione dell’interfaccia utente del client.

//in the js
  function save() {
            if (!xs.buffer.isFinish()) {
              alert('updating is inprogress,please try later');
                return;
            }
            let datas = xs.datas;
            delete datas.history;
            delete datas.search;
            delete datas.images;
            delete datas.shapes;

        var jsondata = {
          sheetname: xs.sheet.data.name,
          actrow: xs.sheet.data.selector.ri,
          actcol: xs.sheet.data.selector.ci,
          datas: xs.getUpdateDatas(),
        };

        const data = {
          p: JSON.stringify(jsondata),
          uid: uniqueid,
        };
		....
		//go on to do ajax post to trigger controller action

//in controller action 
  GridJsWorkbook wb = new GridJsWorkbook();
  wb.MergeExcelFileFromJson(uid, p);
  //after merge do save to chache or to a stream or whaterver you want to save to ,here we just save to cache
  wb.SaveToXlsx(Path.Combine(Config.FileCacheDirectory, uid));

3. ottenere il file dalla cache

ad esempio: nell’azione di download, puoi semplicemente ottenerlo dalla directory della cache tramite uid.

//in controller  

        public async Task<IActionResult> DownloadfromBytes(string uid,string ext)
        {
            byte[] byteArr = await System.IO.File.ReadAllBytesAsync(Path.Combine(Config.FileCacheDirectory, uid) );
            string mimeType = "application/octet-stream";
            return new FileContentResult(byteArr, mimeType)
            {
                FileDownloadName = uid+ ext
            };
        }

Per informazioni più dettagliate, puoi controllare l’esempio qui: https://github.com/aspose-cells/Aspose.Cells-for-.NET/tree/master/Examples_GridJs