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;
}
