public ActionResult WListEdit(int?id) { //a.Open(); var exp = _DbContext.ExportBill.Single(c => c.ExpBId == id); var expdet = _DbContext.ExpBillDetail.Single(c => c.ExpBId == exp.ExpBId); var guitar = _DbContext.Guitars.Single(c => c.GuitarId == expdet.GuitarId); var user = _DbContext.Users.Single(c => c.Id == exp.ExpEmpId); string z = string.Format("select b.ExpBId,g.ImageLink1, d.Product, d.Cost, b.ExpCus, b.ExpDes, b.ExpDate, u.FullName,u.PhoneNumber from AspNetUsers U, ExportBills B, ExpBillDetails D, Guitars G where d.GuitarId = g.GuitarId and b.ExpBId = d.ExpBId and b.ExpEmpid = u.Id and b.ExpBId='{0}'", id); //SqlCommand x = new SqlCommand(z, a); //SqlDataAdapter da = new SqlDataAdapter(x); //da.Fill(dt2); var viewModel = new ExportViewModel { Bid = exp.ExpBId, ImageLink = guitar.ImageLink1, Product = expdet.Product, Cost = expdet.Cost, CusName = exp.ExpCus, BillDes = exp.ExpDes, BillDate = exp.ExpDate, EmployeeName = user.FullName, EmployeephoneNo = user.PhoneNumber }; return(View(viewModel)); }
public ActionResult DefaultStraightFile(string taxonId) { TaxonSearchResult searchResult = this.TaxonSearchManager.GetTaxon(taxonId); if (searchResult.NumberOfMatches != 1) { return(RedirectToSearch(taxonId)); } ITaxon taxon = searchResult.Taxon; this.TaxonIdentifier = TaxonIdTuple.Create(taxonId, searchResult.Taxon.Id); ViewBag.Taxon = taxon; var model = ExportViewModel.Create(GetCurrentUser(), taxon, false); var manager = new ExportManager(model, GetCurrentUser()); manager.CreateExportItems(); ExcelFileFormat fileFormat = ExcelFileFormat.OpenXml; var fileDownloadName = GetValidFileName(taxon.ScientificName) + ExcelFileFormatHelper.GetExtension(fileFormat); MemoryStream excelFileStream = manager.CreateExcelFile(fileFormat); var fileStreamResult = new FileStreamResult(excelFileStream, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"); fileStreamResult.FileDownloadName = fileDownloadName; return(fileStreamResult); }
public ActionResult TaxonList(ExportViewModel model, List <int> filterTaxonCategories, List <int> outputTaxonCategories, List <int> outputTaxonNames, List <int> filterSwedishOccurrence, List <int> filterSwedishHistory, string downloadTokenValue) { if (filterTaxonCategories != null && filterTaxonCategories.Count > 0) { filterTaxonCategories.Remove(model.AllTaxonCategoryId); } if (filterTaxonCategories == null || filterTaxonCategories.Count == 0) { ModelState.AddModelError(string.Empty, "No category is selected"); } ITaxon taxon = CoreData.TaxonManager.GetTaxon(GetCurrentUser(), model.TaxonId); if (ModelState.IsValid) { model.ReInitialize(GetCurrentUser(), taxon, false, filterTaxonCategories, outputTaxonCategories, outputTaxonNames, filterSwedishOccurrence, filterSwedishHistory); var manager = new ExportManager(model, GetCurrentUser()); manager.CreateExportItems(); ExcelFileFormat fileFormat = ExcelFileFormat.OpenXml; MemoryStream excelFileStream = manager.CreateExcelFile(fileFormat); var fileStreamResult = new FileStreamResult(excelFileStream, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"); var fileDownloadName = GetValidFileName(taxon.ScientificName) + ExcelFileFormatHelper.GetExtension(fileFormat); fileStreamResult.FileDownloadName = fileDownloadName; Response.AppendCookie(new HttpCookie("fileDownloadToken", downloadTokenValue)); return(fileStreamResult); } model = ExportViewModel.Create(GetCurrentUser(), taxon, false); return(View(model)); }
public ActionResult Export(ExportViewModel exportViewModel) { Exportor exportor = new Exportor(exportViewModel); exportor.Export(); return(this.RedirectToAction("Index", "Export")); }
protected override async void OnExecute(object parameter) { var dialog = await ExportViewModel.CreateInstanceAsync(this.authenticator, this.cremaAppHost); if (dialog.IsExporting) { AppMessageBox.Show("Now exporting."); return; } if (dialog.LastExportedTables == null || !dialog.LastExportedTables.Any()) { AppMessageBox.Show("No table to export because there is no last export."); return; } if (dialog.CanExport == false) { AppMessageBox.Show("Could not export."); return; } var exportTask = dialog.QuickExportAsync(false, () => dialog?.TryClose()); dialog?.ShowDialog(); await exportTask; }
public async Task <IActionResult> Test(ExportViewModel viewModel) { if (ModelState.IsValid) { using (var memoryStream = new MemoryStream()) { await viewModel.FileContent.CopyToAsync(memoryStream); var body = new ExportRequestBody { FileContent = memoryStream.ToArray(), strFileName = viewModel.FileName, strFolderName = "BEXCELLLE", strProfile = (await _profileRepository.Table.FirstOrDefaultAsync(p => p.ProfileId == 9))?.ProfileName, arrProfileValue = new ArrayOfString { "666", "Profile Pictures" }, userID = "garyfoongck", }; var export = await _docufloSdkService.Export(body); return(Ok(export == "1" ? "Success" : export)); } } return(View(viewModel)); }
public ActionResult Export() { ExportViewModel m = new ExportViewModel(); m.ligues = db.Ligues.ToList(); return(View(m)); }
public ActionResult ExportPOST() { if (!Services.Authorizer.Authorize(Permissions.Export, T("Not allowed to export."))) { return(new HttpUnauthorizedResult()); } var viewModel = new ExportViewModel { ContentTypes = new List <ContentTypeEntry>(), CustomSteps = new List <CustomStepEntry>() }; UpdateModel(viewModel); var contentTypesToExport = viewModel.ContentTypes.Where(c => c.IsChecked).Select(c => c.ContentTypeName); var customSteps = viewModel.CustomSteps.Where(c => c.IsChecked).Select(c => c.CustomStep); var exportOptions = new ExportOptions { ExportMetadata = viewModel.Metadata, ExportSiteSettings = viewModel.SiteSettings, CustomSteps = customSteps }; if (viewModel.Data) { exportOptions.ExportData = true; exportOptions.VersionHistoryOptions = (VersionHistoryOptions)Enum.Parse(typeof(VersionHistoryOptions), viewModel.DataImportChoice, true); } var exportFilePath = _importExportService.Export(contentTypesToExport, exportOptions); return(File(exportFilePath, "text/xml", "export.xml")); }
private void InitViewModels() { Messenger = new PMessenger <ParserEventArgs> { EventAcquired = OnEventAcquired }; TreeViewModel = new ParserTreeViewModel() { Messenger = this.Messenger }; PropertyGridViewModel = new PropertyGridViewModel() { Messenger = this.Messenger }; ExportViewModel = new ExportViewModel() { Messenger = this.Messenger }; LogViewModel = new LogViewModel() { Messenger = this.Messenger }; }
/// <inheritdoc/> public override void ShowInView(IHtmlView htmlView, KeyValueList <string, string> variables, Navigation redirectedFrom) { base.ShowInView(htmlView, variables, redirectedFrom); _viewModel = new ExportViewModel( Ioc.GetOrCreate <INavigationService>(), Ioc.GetOrCreate <ILanguageService>(), Ioc.GetOrCreate <ISvgIconService>(), Ioc.GetOrCreate <IThemeService>(), Ioc.GetOrCreate <IBaseUrlService>(), Ioc.GetOrCreate <IFeedbackService>(), Ioc.GetOrCreate <ICryptoRandomService>(), Ioc.GetOrCreate <IRepositoryStorageService>(), Ioc.GetOrCreate <IFolderPickerService>()); VueBindingShortcut[] shortcuts = new[] { new VueBindingShortcut(VueBindingShortcut.KeyEscape, nameof(InfoViewModel.GoBackCommand)), }; VueBindings = new VueDataBinding(_viewModel, View, shortcuts); _viewModel.VueDataBindingScript = VueBindings.BuildVueScript(); VueBindings.StartListening(); string html = _viewService.GenerateHtml(_viewModel); View.LoadHtml(html); }
public ActionResult NameAuthoritiesByGuide(ExportViewModel evm) { var resources = AsRepo.GetArchivesSpaceResources(); var found = resources.FirstOrDefault(x => x.title + $" ({x.ead_id})" == evm.NewAsResource); var asUrl = ConfigurationManager.AppSettings["ArchivesSpaceUrl"] + found.id; var requests = SearchNameByAsUri(asUrl); var csv = new StringBuilder(); csv.AppendLine("id,authoritativeLabel,type"); var type = string.Empty; foreach (var result in requests.Results.Docs) { if (result.creator != null && result.creator.Contains(asUrl)) { type = "creator"; } else if (result.source != null && result.source.Contains(asUrl)) { type = "source"; } //else if (result.corporateNameCreator != null && result.corporateNameCreator.Contains(asUrl)) { type = "corporateNameCreator"; } //else if (result.corporateNameSource != null && result.corporateNameSource.Contains(asUrl)) { type = "corporateNameSource"; } //else if (result.familyNameCreator != null && result.familyNameCreator.Contains(asUrl)) { type = "familyNameCreator"; } //else if (result.familyNameSource != null && result.familyNameSource.Contains(asUrl)) { type = "familyNameSource"; } csv.AppendLine($"{result._id},\"{result.authoritativeLabel}\",{type}"); } System.IO.File.WriteAllText(Server.MapPath($"~/Download/{found.ead_id}NameAuths.csv"), csv.ToString(), Encoding.UTF8); return(Redirect($"~/Download/{found.ead_id}NameAuths.csv")); }
public ActionResult ExportPOST(ExportViewModel viewModel) { if (!Services.Authorizer.Authorize(Permissions.Export, T("Not allowed to export."))) { return(new HttpUnauthorizedResult()); } var actions = _exportActions.OrderByDescending(x => x.Priority).ToList(); foreach (var action in actions) { action.UpdateEditor(Services.New, this); } var exportActionContext = new ExportActionContext(); _importExportService.Export(exportActionContext, actions); var recipeDocument = exportActionContext.RecipeDocument; var exportFilePath = _importExportService.WriteExportFile(recipeDocument); var recipe = _recipeParser.ParseRecipe(recipeDocument); var exportFileName = recipe.GetExportFileName(); return(File(exportFilePath, "text/xml", exportFileName)); }
public JsonResult SetupWithParams(int parentId, [FromBody] ExportViewModel model) { var settings = new ExportSettings { DateTimeForFileName = DateTime.Now, Culture = ((CsvCulture)int.Parse(model.Culture)).Description(), Delimiter = char.Parse(((CsvDelimiter)int.Parse(model.Delimiter)).Description()), Encoding = ((CsvEncoding)int.Parse(model.Encoding)).Description(), LineSeparator = ((CsvLineSeparator)int.Parse(model.LineSeparator)).Description(), AllFields = model.AllFields, OrderByField = model.OrderByField }; if (!settings.AllFields) { settings.CustomFieldIds = model.CustomFields.ToList(); settings.ExcludeSystemFields = model.ExcludeSystemFields; } settings.FieldIdsToExpand = model.FieldsToExpand.ToList(); _service.SetupWithParams(parentId, model.Ids, settings); return(JsonCamelCase(new JSendResponse { Status = JSendStatus.Success })); }
public ExportDialog(ExportViewModel viewModel) { this.viewModel = viewModel; DataContext = viewModel; InitializeComponent(); }
private void BindDataContext(Document document) { var hasSelection = ExportProvider.HasSelection; var viewModel = new ExportViewModel(hasSelection, document.Cultures); DataContext = viewModel; }
/// <summary> /// Creates a new instance of the <see cref="ExportViewModel" /> class based on the given expenditure. /// </summary> /// <param name="apiResponseExpenditures">The API response expenditures.</param> /// <param name="exportType">Type of the export.</param> /// <returns> /// The view model. /// </returns> /// <exception cref="System.ArgumentOutOfRangeException"> /// Exception thrown if the given export type is out of range. /// </exception> public ExportViewModel NewExportViewModel( IList <ExpenditureProxy> apiResponseExpenditures, ExportType exportType) { var retVal = new ExportViewModel { ExportType = exportType, FileName = "expenditure" }; switch (exportType) { case ExportType.Csv: retVal.FileData = ExportHelper.ToCsv(apiResponseExpenditures); break; case ExportType.Xml: retVal.FileData = ExportHelper.ToXml(apiResponseExpenditures); break; case ExportType.Json: retVal.FileData = ExportHelper.ToJson(apiResponseExpenditures); break; default: throw new ArgumentOutOfRangeException(nameof(exportType), exportType, null); } return(retVal); }
public async Task <IActionResult> Create(ExportViewModel fn) { int fileid = await GetIdFromFileName(fn.FileName); if (fileid == 0) { return(RedirectToAction("Index")); } string myid = _userManager.GetUserId(User); Sequencer sequencer = new Sequencer { Active = false, LastTime = DateTime.Now.ToUniversalTime(), NoteFileId = fileid, Ordinal = await GetNextOrdinal(myid), StartTime = DateTime.Now.ToUniversalTime(), UserId = myid }; try { _db.Sequencer.Add(sequencer); await _db.SaveChangesAsync(); } catch { // ignored } return(RedirectToAction("Index")); }
// GET: Sequencers/Create public IActionResult Create() { // Get a list of all file names for dropdown IEnumerable <SelectListItem> items = LocalManager.GetFileNameSelectList(_db); List <SelectListItem> list2 = new List <SelectListItem> { new SelectListItem { Value = "", Text = "-- Select a File --" } }; list2.AddRange(items); ExportViewModel it = new ExportViewModel { AFiles = list2 }; // Get a list of all file titles for dropdown items = LocalManager.GetFileTitleSelectList(_db); list2 = new List <SelectListItem> { new SelectListItem { Value = "", Text = "-- Select a Title --" } }; list2.AddRange(items); it.ATitles = list2; return(View(it)); }
/// <summary> /// Parse and display the new input stream /// </summary> private void CreatePaths(string stream) { GraphicPath path; try { var streamGeometryParser = new StreamGeometryParser(); var graphicPathGeometry = streamGeometryParser.ParseGeometry(stream); path = new GraphicPath(); path.Geometry = graphicPathGeometry; path.FillBrush = new GraphicSolidColorBrush { Color = Color.FromRgb(128, 128, 128) }; ShowError = false; } catch { path = null; ShowError = true; } PreviewViewModel.SetNewGraphicPath(path); ResourceViewModel.SetNewGraphicVisual(path); XamlViewModel.SetNewGraphicVisual(path); CSharpViewModel.SetNewGraphicVisual(path); ExportViewModel.SetNewGraphicVisual(path); }
protected async override void OnExecute(object parameter) { if (this.cremaAppHost.GetService(typeof(IDataBase)) is IDataBase dataBase) { var viewModel = parameter as TreeViewItemViewModel; var query = from item in viewModel.Items where item.Target is ITable let table = item.Target as ITable select table; var paths = await dataBase.Dispatcher.InvokeAsync(() => { return(query.Where(item => item.VerifyAccessType(this.authenticator, AccessType.Guest)). Select(item => item.Path). Distinct(). ToArray()); }); if (paths.Any() == false) { await AppMessageBox.ShowAsync(Resources.Message_NoneTablesToExport); } else { var dialog = await ExportViewModel.CreateInstanceAsync(this.authenticator, this.cremaAppHost, paths); if (dialog != null) { await dialog.ShowDialogAsync(); } } } }
/// <summary> /// Prepare all data for the graphic path selection listbox /// </summary> void PrepSelectionList() { if (graphicVisual != null) { var previewIcons = new List <PreviewShapeViewModel>(); int index = 0; CreateShapeSelectionList(graphicVisual, previewIcons, ref index); PreviewShapes = previewIcons; if (previewIcons.Count > 0) { TriggerResetView.Fire(); ResourceViewModel.Reset(); XamlViewModel.Reset(); CSharpViewModel.Reset(); } SelectAllPreviewIcons(true); } else { PreviewShapes = null; PreviewViewModel.SetNewGraphicVisual(null); ResourceViewModel.SetNewGraphicVisual(null); XamlViewModel.SetNewGraphicVisual(null); CSharpViewModel.SetNewGraphicVisual(null); ExportViewModel.SetNewGraphicVisual(null); } }
public ExportDialog(Models.Models models, string filename, ImageLoader.ImageFormat defaultPixelFormat, ExportModel.FileFormat format) { models.Export.Init(filename, defaultPixelFormat, format); viewModel = new ExportViewModel(models); DataContext = viewModel; InitializeComponent(); }
/// <summary> /// Constructor /// </summary> public StreamConverterViewModel() { PreviewViewModel = new PreviewViewModel(); ResourceViewModel = new ResourceViewModel(); XamlViewModel = new XamlViewModel(); CSharpViewModel = new CSharpViewModel(); ExportViewModel = new ExportViewModel(); }
protected async override void OnExecute(object parameter) { if (parameter is ITableDescriptor descriptor) { var dialog = await ExportViewModel.CreateInstanceAsync(this.authenticator, descriptor); dialog?.ShowDialog(); } }
public void EnumerateNotesToExport_DoesNotReturnProtectedNoteBecauseSafeIsClosed() { NoteRepositoryModel repository = CreateTestRepository(); var notes = ExportViewModel.EnumerateNotesToExport(repository, true, true).ToList(); Assert.AreEqual(2, notes.Count); Assert.AreSame(repository.Notes[1], notes[0]); Assert.AreSame(repository.Notes[2], notes[1]); }
public void EnumerateNotesToExport_ReturnsProtectedNotesOnly() { NoteRepositoryModel repository = CreateTestRepository(); repository.Safes[0].Key = new byte[] { 88 }; var notes = ExportViewModel.EnumerateNotesToExport(repository, false, true).ToList(); Assert.AreEqual(1, notes.Count); Assert.AreSame(repository.Notes[0], notes[0]); }
public ActionResult Export(ExportViewModel model) { var cd = new ContentDisposition { FileName = "YourFileName.csv", Inline = false }; Response.AddHeader("Content-Disposition", cd.ToString()); return(Content(model.Csv, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")); }
public ActionResult Export() { var actions = _exportActions.OrderByDescending(x => x.Priority).Select(x => new ExportActionViewModel { Editor = x.BuildEditor(Services.New) }).Where(x => x != null).ToList(); var viewModel = new ExportViewModel { Actions = actions }; return(View(viewModel)); }
public void EnumerateNotesToExport_ReturnsUnprotectedNotesOnly() { NoteRepositoryModel repository = CreateTestRepository(); repository.Notes[0].SafeId = repository.Safes[0].Id; var notes = ExportViewModel.EnumerateNotesToExport(repository, true, false).ToList(); Assert.AreEqual(2, notes.Count); Assert.AreSame(repository.Notes[1], notes[0]); Assert.AreSame(repository.Notes[2], notes[1]); }
public async Task <FileResult> Index(ExportViewModel model /*, int arcId*/) { int?arcId = HttpContext.Session.GetInt32("ArchiveID"); int arcId2 = 0; if (arcId != null) { arcId2 = (int)arcId; } return(File(await DoExport(model, User, arcId2), System.Net.Mime.MediaTypeNames.Application.Octet, model.FileName + (model.isHtml ? ".html" : ".txt"))); }
public ExportViewModel BuildFrom(ExportMenuViewModel exportMenuViewModel, bool renderAsPdf) { var exportViewModel = new ExportViewModel { RenderAsPdf = renderAsPdf, InternalView = exportMenuViewModel.InternalView, Property = _buildExportPropertyViewModel.BuildWith(exportMenuViewModel), ServiceHistoryModels = _buildExportServiceHistoryViewModel.BuildFrom(exportMenuViewModel), PropertyNotesModel = _buildExportPropertyNotesViewModel.BuildFrom(exportMenuViewModel), WorkItemViewModels = _buildExportWorkItemViewModel.BuildFrom(exportMenuViewModel), Photos = _buildExportPhotosViewModel.BuildFrom(exportMenuViewModel, renderAsPdf), }; return exportViewModel; }