/// <summary> /// Сохранить файл /// </summary> /// <param name="stream"></param> /// <param name="fileName"></param> /// <param name="userIdentityid"></param> /// <param name="exportType"></param> /// <returns></returns> public async Task <ExportedFile> SaveExportedFile(Stream stream, string fileName, int userIdentityid, EExportType exportType) { if (stream == null) { throw new Exception("Входной файл не определен"); } var exchangeFileId = await SaveFile(stream, fileName, userIdentityid); using (var context = new ApplicationDbContext()) { //создам сущность экспортируемого файла var exportedFile = new ExportedFile { UnloadType = exportType, UnloadStatus = EUnloadStatus.InProcess, ExchangeFile = await context.ExchangeFiles.FindAsync(exchangeFileId), Organization = context.Employee.Where(x => x.ApplicationUser.Id == userIdentityid) .Select(x => x.Organization) .FirstOrDefault() }; context.ExportedFiles.Add(exportedFile); await context.SaveChangesAsync(); return(exportedFile); } }
public override void VisitFile(ExportedFile file) { bool hasReferences = false, hasImports = false; foreach (var rtReference in file.FinalReferences) { Visit(rtReference); hasReferences = true; } foreach (var rtImport in file.FinalImports) { Visit(rtImport); hasImports = true; } if (hasReferences || hasImports) { Br(); } foreach (var fileNamespace in file.Namespaces) { Visit(fileNamespace); } }
public void Export(string fileName, ExportedFile file) { StringBuilder sb = new StringBuilder(); using (var sw = new StringWriter(sb)) { ExportCore(sw, file); } ExportedFiles[fileName] = sb.ToString(); }
public void Export(string fileName, ExportedFile file, ReferenceProcessorBase refProcessor = null) { StringBuilder sb = new StringBuilder(); using (var sw = new StringWriter(sb)) { ExportCore(sw, file, refProcessor); } ExportedFiles[fileName] = sb.ToString(); }
public void Export(string fileName, ExportedFile file) { StringBuilder sb = new StringBuilder(); using (var sw = new StringWriter(sb)) { sw.NewLine = Context.Global.NewLine; ExportCore(sw, file); } ExportedFiles[fileName] = sb.ToString(); }
protected virtual void ExportCore(TextWriter tw, ExportedFile file, ReferenceProcessorBase refProcessor = null) { var visitor = Context.Global.ExportPureTypings ? new TypingsExportVisitor(tw, Context.Global.TabSymbol, Context.Global.ReorderMembers) : new TypeScriptExportVisitor(tw, Context.Global.TabSymbol, Context.Global.ReorderMembers); WriteWarning(tw); var references = file.References.References; if (refProcessor != null) { references = refProcessor.FilterReferences(references, file); if (references == null) { references = new RtReference[0]; } } bool hasReferences = false; foreach (var rtReference in references) { visitor.Visit(rtReference); hasReferences = true; } var imports = file.References.Imports; if (refProcessor != null) { imports = refProcessor.FilterImports(imports, file); if (imports == null) { imports = new RtImport[0]; } } bool hasImports = false; foreach (var rtImport in imports) { visitor.Visit(rtImport); hasImports = true; } if (hasReferences || hasImports) { tw.WriteLine(); } foreach (var fileNamespace in file.Namespaces) { visitor.Visit(fileNamespace); } }
protected virtual void ExportCore(TextWriter tw, ExportedFile file) { var visitor = Context.Global.VisitorType == null ? Context.Global.ExportPureTypings ? new TypingsExportVisitor(tw, Context) : new TypeScriptExportVisitor(tw, Context) : (TextExportingVisitor)Activator.CreateInstance(Context.Global.VisitorType, new object[] { tw, Context }); WriteWarning(tw); visitor.VisitFile(file); }
public override void VisitFile(ExportedFile file) { base.VisitFile(file); var ns = file.Namespaces.FirstOrDefault(); if (ns != null) { WriteLines($@" export = {ns.Name}; "); } }
/// <summary> /// Запуск экспорта /// </summary> /// <returns></returns> public async Task Run(IPrincipal principal) { try { var userIdentityid = principal.Identity.GetUserId <int>(); try { var exportedFile = (await FileStorageManager.SaveExportedFile(new MemoryStream(), "empty.txt", userIdentityid, UnloadType)); var exportResult = ExportData(userIdentityid, exportedFile.Id).Result; FileStorageManager.UpdateFile(exportedFile.ExchangeFileId, exportResult.Data, exportResult.FileName, userIdentityid); using (var context = new ApplicationDbContext()) { context.ExportedFiles.Find(exportedFile.Id).UnloadStatus = exportResult.Status; var file = context.ExchangeFiles.Find(exportedFile.ExchangeFileId); file.FinishTime = DateTime.Now; file.Progress = 1m; await context.SaveChangesAsync(); } } catch { using (var context = new ApplicationDbContext()) { var unloadedFile = new ExportedFile { UnloadType = UnloadType, UnloadStatus = EUnloadStatus.UnloadError, ExchangeFile = null }; context.ExportedFiles.Add(unloadedFile); await context.SaveChangesAsync(); } throw; } } catch (Exception ex) { LogUtils.WriteException(ex, LogUtils.ELogType.Error); } }
/// <summary> /// Ensures that imports for specified type presents in specified file /// </summary> /// <param name="t">Type to import</param> /// <param name="typeName">Type name (probably overriden)</param> /// <param name="file">Exported file</param> /// <returns>Import AST node or null if no import needed. Returns existing import in case if type is already imported</returns> public RtImport EnsureImport(Type t, string typeName, ExportedFile file) { if (file.TypesToExport.Contains(t)) { return(null); } if (file.AllTypesIsSingleFile) { return(null); } var relPath = GetRelativePathForType(t, file.FileName); if (string.IsNullOrEmpty(relPath)) { return(null); } RtImport result = null; if (file.References.StarImports.ContainsKey(relPath)) { return(file.References.StarImports[relPath]); } if (_context.Global.DiscardNamespacesWhenUsingModules) { var target = string.Format("{{ {0} }}", typeName); result = new RtImport() { From = relPath, Target = target }; file.References.AddImport(result); } else { var alias = Path.GetFileNameWithoutExtension(relPath); var target = string.Format("* as {0}", alias); result = new RtImport() { From = relPath, Target = target }; file.References.AddImport(result); } return(result); }
/// <summary> /// Ensures that reference for specified type presents in specified file /// </summary> /// <param name="t">Type to reference</param> /// <param name="file">Exported file</param> /// <returns>Reference AST node or null if no reference needed. Returns existing reference in case if type is already referenced</returns> public RtReference EnsureReference(Type t, ExportedFile file) { if (file.TypesToExport.Contains(t)) { return(null); } if (file.AllTypesIsSingleFile) { return(null); } var relPath = GetRelativePathForType(t, file.FileName); var result = new RtReference() { Path = relPath }; file.References.AddReference(result); return(result); }
protected virtual void ExportCore(TextWriter tw, ExportedFile file) { var visitor = Context.Global.ExportPureTypings ? new TypingsExportVisitor(tw, Context.Global.TabSymbol) : new TypeScriptExportVisitor(tw, Context.Global.TabSymbol); WriteWarning(tw); foreach (var rtReference in file.References.References) { visitor.Visit(rtReference); } foreach (var rtImport in file.References.Imports) { visitor.Visit(rtImport); } if (file.References.References.Any() || file.References.Imports.Any()) { tw.WriteLine(); } foreach (var fileNamespace in file.Namespaces) { visitor.Visit(fileNamespace); } }
public abstract T VisitFile(ExportedFile file);
/// <summary> /// Returns refiltered and reordered reference directives that must appear in resulting file /// Return null to remain imports list untouched /// </summary> /// <param name="references">Set on initially computed references</param> /// <param name="file">File that is being exported currently</param> /// <returns>Set of refiltered/reordered references</returns> public override IEnumerable <RtReference> FilterReferences(IEnumerable <RtReference> references, ExportedFile file) { // same rules as for imports // keep in mind that references are ALWAYS being written // whereas imports are not being used until .UseModules set to true if (file.FileName.EndsWith("kendo.ts")) { return(references); } return(FilterMainFileReferences(references)); }
/// <summary> /// Returns refiltered and reordered reference directives that must appear in resulting file /// Return null to remain imports list untouched /// </summary> /// <param name="references">Set on initially computed references</param> /// <param name="file">File that is being exported currently</param> /// <returns>Set of refiltered/reordered references</returns> public abstract IEnumerable <RtReference> FilterReferences(IEnumerable <RtReference> references, ExportedFile file);
/// <summary> /// Returns refiltered and reordered import directives that must appear in resulting file. /// Return null to remain references list untouched /// </summary> /// <param name="imports">Set on initially computed imports</param> /// <param name="file">File that is being exported currently</param> /// <returns>Set of refiltered/reordered imports</returns> public abstract IEnumerable <RtImport> FilterImports(IEnumerable <RtImport> imports, ExportedFile file);
public abstract void VisitFile(ExportedFile file);
public override void VisitFile(ExportedFile file) { }
/// <summary> /// Returns refiltered and reordered import directives that must appear in resulting file. /// Return null to remain references list untouched /// </summary> /// <param name="imports">Set on initially computed imports</param> /// <param name="file">File that is being exported currently</param> /// <returns>Set of refiltered/reordered imports</returns> public override IEnumerable <RtImport> FilterImports(IEnumerable <RtImport> imports, ExportedFile file) { // here we also can return null to quickly reset references/imports list if (file.FileName.EndsWith("kendo.ts")) { return(imports); } // modify imports only in meaningful file return(FilterMainFileImports(imports)); }