public void ReConnect(IJiraConnectionSettings newJiraConnectionSettings, IExportSettings newExportSettings) { exportSettings = newExportSettings; jiraConnectionSettings = newJiraConnectionSettings; CheckAndConnectJira(); UpdateJiraProjectCache(); }
internal static void ExportView(string viewName, string path, IExportSettings options) { ExportEngine ee = new ExportEngine(); ee.ExportView(viewName, path, options); ee.Close(); // does nothing, not needed }
/// <summary> /// This method is called by all exports methods, it takes care of all the actual exports. /// Other export methods are really just preparation routines for calling this method. /// </summary> /// <param name="cur">ICommenceCursor</param> /// <param name="fileName">file name</param> /// <param name="settings">IExportSettings</param> internal void ExportCursor(ICommenceCursor cur, string fileName, IExportSettings settings) { // exporting may take a long time, and the system may go into power saving mode // this is annoying, so we tell the system not to go into sleep/hibernation // this may or may not be a good idea... PowerSavings ps = new PowerSavings(); try { ps.EnableConstantDisplayAndPower(true, "Performing time-consuming Commence export"); cur.MaxFieldSize = this.Settings.MaxFieldSize; // remember setting this size greatly impacts memory usage! using (_writer = this.GetExportWriter(cur, settings)) { SubscribeToWriterEvents(_writer); _writer.WriteOut(fileName); } } finally { ps.EnableConstantDisplayAndPower(false); // CODE SMELL, may overwrite things UnsubscribeToWriterEvents(_writer); _writer?.Dispose(); } }
public ExcelWriterUsingOpenXml(ICommenceCursor cursor, IExportSettings settings) : base(cursor, settings) { columnDefinitions = new List <ColumnDefinition>(_settings.UseThids ? base.ColumnDefinitions.Skip(1) : base.ColumnDefinitions); _sheetName = string.IsNullOrEmpty(settings.CustomRootNode) ? Utils.EscapeString(_dataSourceName, "_").Left(MaxSheetNameLength) : settings.CustomRootNode; settings.ISO8601Format = true; // override custom setting(s) settings.SplitConnectedItems = false; // override custom setting(s) }
private void BtnPrintBarCode_Click_Extend(object sender, EventArgs e) { this.Model.ClearErrorMessage(); try { IList <IUIRecord> selectedRecords = this.Model.ProductBarCode.Cache.GetSelectRecord(); if (selectedRecords == null || selectedRecords.Count == 0) { throw new Exception("没有选择需要打印条码的记录!"); } UIActionEventArgs args = new UIActionEventArgs(); IExportSettings settings = ExportServiceFactory.GetInstance().CreateExportSettingsObject(); settings.PrintTemplateCatalogType = printTemplateCatalogType; settings.UserDataCallBack = DataCallBackHandle; // 打印完成委托 settings.OnFinished = new FinishCallBackHandle(FinishCallBackHandle); args.Tag = settings; CommandFactory.DoCommand("OnPrint", this.Action, sender, args); } catch (Exception ex) { IUIModel model = this.Model; this.Model.ErrorMessage.SetErrorMessage(ref model, ex.Message); } BtnPrintBarCode_Click_DefaultImpl(sender, e); }
/// <summary> /// Transform the images ready for download, optionally adding a watermark. /// </summary> /// <param name="input"></param> /// <param name="output"></param> /// <param name="waterMarkText"></param> public void TransformDownloadImageSync(string input, Stream output, IExportSettings config) { using SKImage img = SKImage.FromEncodedData(input); using var bitmap = SKBitmap.FromImage(img); float maxSize = config.MaxImageSize; var resizeFactor = 1f; if (bitmap.Width > maxSize) { resizeFactor = maxSize / bitmap.Width; } else if (bitmap.Height > maxSize) { resizeFactor = maxSize / bitmap.Height; } var targetWidth = (int)Math.Round(bitmap.Width * resizeFactor); var targetHeight = (int)Math.Round(bitmap.Height * resizeFactor); // First create a bitmap the right size. using var toBitmap = new SKBitmap(targetWidth, targetHeight, bitmap.ColorType, bitmap.AlphaType); using var canvas = new SKCanvas(toBitmap); // Draw a bitmap rescaled canvas.SetMatrix(SKMatrix.CreateScale(resizeFactor, resizeFactor)); canvas.DrawBitmap(bitmap, 0, 0); canvas.ResetMatrix(); if (!string.IsNullOrEmpty(config.WatermarkText)) { using var font = SKTypeface.FromFamilyName("Arial"); using var brush = new SKPaint { Typeface = font, TextSize = 64.0f, IsAntialias = true, Color = new SKColor(255, 255, 255, 255) }; var textWidth = brush.MeasureText(config.WatermarkText); var textTargetWidth = targetWidth / 6f; var fontScale = textTargetWidth / textWidth; brush.TextSize *= fontScale; // Offset by text width + 10% var rightOffSet = (textTargetWidth * 1.1f); canvas.DrawText(config.WatermarkText, targetWidth - rightOffSet, targetHeight - brush.TextSize, brush); } canvas.Flush(); using var image = SKImage.FromBitmap(toBitmap); using var data = image.Encode(SKEncodedImageFormat.Jpeg, 90); data.SaveTo(output); }
internal SQLiteToXmlSerializer(IExportSettings settings, DataTable primaryTable, string connectionString) { _settings = settings; _cs = connectionString; _primaryTable = primaryTable; }
public SettingsCollection() { AppSettings = new AppSettings(); JiraConnectionSettings = new JiraConnectionSettings(); UiSettings = new UiSettings(); InternalSettings = new InternalSettings(); ExportSettings = new ExportSettings(); }
public SettingsCollection(IAppSettings appSettings, IJiraConnectionSettings jiraConnectionSettings, IUiSettings uiSettings, IInternalSettings internalSettings, IExportSettings exportSettings) { AppSettings = appSettings; JiraConnectionSettings = jiraConnectionSettings; UiSettings = uiSettings; InternalSettings = internalSettings; ExportSettings = exportSettings; }
public void ReConnect(IJiraConnectionSettings newJiraConnectionSettings, IExportSettings newExportSettings) { exportSettings = newExportSettings; jiraConnectionSettings = newJiraConnectionSettings; jira = null; CheckAndConnectJira(); Task.Factory.StartNew(UpdateJiraProjectCache); }
internal SQLiteToJsonSerializer(IExportSettings settings, OriginalCursorProperties ocp, DataTable primaryTable, string connectionString) { _settings = settings; _ocp = ocp; _cs = connectionString; _primaryTable = primaryTable; }
public SettingsCollection(ISettingsCollection settings) { AppSettings = settings.AppSettings; JiraConnectionSettings = settings.JiraConnectionSettings; UiSettings = settings.UiSettings; InternalSettings = settings.InternalSettings; ExportSettings = settings.ExportSettings; isIntialised = false; }
/// <summary> /// Convert an image, optionally watermarking. /// </summary> /// <param name="input"></param> /// <param name="output"></param> /// <param name="config"></param> /// TODO: Async public async Task TransformDownloadImage(string input, Stream output, IExportSettings exportConfig) { var ext = Path.GetExtension(input); var processor = _factory.GetProcessor(ext); if (processor != null) { await processor.TransformDownloadImage(input, output, exportConfig); } }
public void Initialise() { var settings = SettingsCollectionSerializer.DeSerialize(); AppSettings = settings.AppSettings; JiraConnectionSettings = settings.JiraConnectionSettings; UiSettings = settings.UiSettings; InternalSettings = settings.InternalSettings; ExportSettings = settings.ExportSettings; isIntialised = true; }
public static async Task ExportAsync(this ISession session, IExportSettings settings, ILogger log, Func <DynamicContent, Task> handler) { var ctx = QueryContext.Default.Unpublished(settings.Unpublished); var contents = session.Contents(settings.Schema); var total = 0L; var totalRead = 0; var currentPage = 0; var handled = new HashSet <string>(); using (var logLine = log.WriteSameLine()) { do { var query = new ContentQuery { Filter = settings.Filter, OrderBy = settings.OrderBy, Search = settings.FullText, Skip = currentPage * 100, Top = 100 }; var content = await contents.GetAsync(query, ctx); total = content.Total; if (content.Items.Count == 0) { break; } foreach (var entity in content.Items) { if (handled.Add(entity.Id)) { totalRead++; await handler(entity); logLine.WriteLine("> Exported: {0} of {1}.", totalRead, total); } } currentPage++; }while (totalRead < total); } log.WriteLine("> Exported: {0} of {1}. Completed.", totalRead, total); }
private void CustomerItemPrint_Click(object sender, EventArgs e) { //输出服务 IExportSettings settings = ExportServiceFactory.GetInstance().CreateExportSettingsObject(); //最末一级分类目录的实体key settings.PrintTemplateCatalogType = "UFIDA.U9.CBO.SCM.Customer.CustomerItem"; //从GetPrintDataNew()方法取数 settings.UserDataCallBack = new DataCallBackHandle(this.GetPrintDataNew); UIActionEventArgs ex = new UIActionEventArgs(); ex.Tag = settings; UFIDA.U9.UI.Commands.CommandFactory.DoCommand("OnPrint", (BaseAction)part.Action, sender, ex); }
/// <summary> /// Constructor used when exporting cursor. /// </summary> /// <param name="cursor">Database.ICommenceCursor.</param> /// <param name="settings">ExportSettings object.</param> /// <exception cref="ArgumentOutOfRangeException"></exception> /// <exception cref="ArgumentException"></exception> protected internal BaseWriter(ICommenceCursor cursor, IExportSettings settings) { _cursor = cursor; _settings = settings; // this check is very important if (_settings.HeaderMode == HeaderMode.CustomLabel) { if (ValidCustomHeaders(_settings.CustomHeaders.Select(x => x.ToString()).ToArray())) { _customColumnHeaders = _settings.CustomHeaders.Select(x => x.ToString()).ToArray(); _customColumnHeaders = Utils.RenameDuplicates(_customColumnHeaders.ToList()).ToArray(); } } _dataSourceName = (string.IsNullOrEmpty(_cursor.View)) ? _cursor.Category : _cursor.View; _cursor.SeekRow(CmcCursorBookmark.Beginning, 0); // put rowpointer on first item }
internal DataReader(ICommenceCursor cursor, IExportSettings settings, List <ColumnDefinition> columndefinitions) { this.cursor = (CommenceCursor)cursor; totalRows = cursor.RowCount; this.settings = settings; numRows = (int)Math.Pow(2, BalanceNumRowsAndFieldSize(settings)); if (settings.NumRows < numRows) { numRows = settings.NumRows; } this.columnDefinitions = columndefinitions; regex = new Regex(pattern); if (this.cursor.Flags.HasFlag(CmcOptionFlags.UseThids)) { useThids = true; } }
/// <inheritdoc /> public void ExportView(string viewName, string fileName, IExportSettings settings = null) { if (settings != null) { this.Settings = settings; } // use user-supplied settings using (var db = new CommenceDatabase()) { string _viewName = string.IsNullOrEmpty(viewName) ? GetActiveViewName(db) : viewName; using (ICommenceCursor cur = db.GetCursor(_viewName, CmcCursorType.View, this.Settings.UseThids ? CmcOptionFlags.UseThids : CmcOptionFlags.Default)) { ExportCursor(cur, fileName, this.Settings); } } }
private void BtnPrintBarCode_Click_Extend(object sender, EventArgs e) { this.Model.ClearErrorMessage(); IList <IUIRecord> selectedRecords = this.Model.CompleteApplyBarCode.Cache.GetSelectRecord(); if (selectedRecords == null || selectedRecords.Count == 0) { IUIModel model = this.Model; this.Model.ErrorMessage.SetErrorMessage(ref model, "没有选择需要打印条码的记录!"); return; } bool checkFail = false; foreach (CompleteApplyBarCodeRecord selectedRecord in selectedRecords) { //打印外包装允许可以打印条码2次,否则只能允许打印1次 if (((selectedRecord.IsPrintWrapper ?? false) && selectedRecord.PrintCount >= 2) || (!(selectedRecord.IsPrintWrapper ?? false) && selectedRecord.PrintCount >= 1)) { IUIRecord record = selectedRecord; string errorMessage = string.Format("条码{0}已经超出打印次数,不允许打印", selectedRecord.BarCode); this.Model.ErrorMessage.SetErrorMessage(ref record, "", errorMessage); checkFail = true; } } if (checkFail) { return; } UIActionEventArgs args = new UIActionEventArgs(); IExportSettings settings = ExportServiceFactory.GetInstance().CreateExportSettingsObject(); settings.PrintTemplateCatalogType = printTemplateCatalogType; settings.UserDataCallBack = DataCallBackHandle; // 打印完成委托 settings.OnFinished = new FinishCallBackHandle(FinishCallBackHandle); args.Tag = settings; CommandFactory.DoCommand("OnPrint", this.Action, sender, args); BtnPrintBarCode_Click_DefaultImpl(sender, e); }
/// <summary> /// Factory method for creating the required export writer object for a cursor export. /// </summary> /// <param name="cursor">Database.ICommenceCursor .</param> /// <param name="settings">Settings object.</param> /// <returns>Derived BaseDataWriter object.</returns> /// <remarks>Defaults to XML.</remarks> internal BaseWriter GetExportWriter(ICommenceCursor cursor, IExportSettings settings) { if (!settings.PreserveAllConnections && settings.NestConnectedItems && settings.ExportFormat == ExportFormat.Json) { return(new AdoNetWriter(cursor, settings)); // i think this can be taken out entirely } if (settings.PreserveAllConnections) { return(new Complex.SQLiteWriter(cursor, settings)); } switch (settings.ExportFormat) { case ExportFormat.Text: return(new TextWriter(cursor, settings)); case ExportFormat.Html: return(new HtmlWriter(cursor, settings)); case ExportFormat.Xml: return(new XmlWriter(cursor, settings)); case ExportFormat.Json: return(new JsonWriter(cursor, settings)); case ExportFormat.Excel: //_writer = new ExcelWriterUsingXml(cursor, settings); //return new ExcelWriterUsingOleDb(cursor, settings); //return new ExcelWriterUsingOpenXml(cursor, settings); return(new ExcelWriterUsingEPPlus(cursor, settings)); case ExportFormat.Event: return(new EventWriter(cursor, settings)); case ExportFormat.GoogleSheets: // will probably always be too slow throw new NotImplementedException("Exportformat not yet implemented."); default: return(new XmlWriter(cursor, settings)); } }
internal ExcelWriterUsingEPPlus(ICommenceCursor cursor, IExportSettings settings) : base(cursor, settings) { string s = string.IsNullOrEmpty(settings.CustomRootNode) ? _dataSourceName : settings.CustomRootNode; _dataTable = PrepareDataTable(s, base.ColumnDefinitions); _sheetName = Utils.EscapeString(s, "_").Left(MaxSheetNameLength); settings.Canonical = true; // override custom setting settings.SplitConnectedItems = false; // override custom setting // When dealing with very large cursors, // the default number of rows read may lead to memory issues when dumping to a datatable // we may have to cap the number of items being read // This superceeds the check already performed in the datareader. // I am undecided on this. // What I do know is that writing 1000 rows of 250 columns of size 30.000 // (i.e. 250 large text fields, fully populated) will fail. // Maybe we should have some mechanism that collects the size of the fields // then caps the NumRows count accordingly. // However, it would not solve issues with EPPlus running out of memory when dealing with huge workbooks. }
public ExportModel(JiraTimer timer, TimeSpan? exportTime, IExportSettings exportSettings) { UpdateTimer(timer, exportTime); ExportDate = timer.DateStarted.Date != DateTime.Now.Date ? timer.DateStarted.Date.AddHours(12) : DateTime.Now; switch (exportSettings.DefaultRemainingValue) { case DefaultRemaining.Auto: WorkLogStrategy = WorkLogStrategy.Automatic; break; case DefaultRemaining.Leave: WorkLogStrategy = WorkLogStrategy.LeaveRemaining; break; case DefaultRemaining.Set: WorkLogStrategy = WorkLogStrategy.SetValue; break; } DefaultComment = exportSettings.EmptyExportComment; }
/// <inheritdoc /> public void ExportCategory(string categoryName, string fileName, IExportSettings settings = null) { if (settings != null) { this.Settings = settings; } // use custom settings if supplied CmcOptionFlags flags = this.Settings.UseThids ? CmcOptionFlags.UseThids : CmcOptionFlags.Default | CmcOptionFlags.IgnoreSyncCondition; // User requested we skip connections. // A default cursor on a category contains all fields *and* connections. // The data receiving routines will ignore them, but they will be read unless we do not include them in our cursor // We optimize here by only including direct fields in the cursor using (var db = new CommenceDatabase()) { if (this.Settings.SkipConnectedItems && this.Settings.HeaderMode != HeaderMode.CustomLabel) { using (ICommenceCursor cur = GetCategoryCursorFieldsOnly(db, categoryName, flags)) { // we can limit MAX_FIELD_SIZE in this case this.Settings.MaxFieldSize = (int)Math.Pow(2, 15); // 32.768, the built-in Commence max fieldlength (large text) is 30.000 ExportCursor(cur, fileName, this.Settings); } } else { using (ICommenceCursor cur = GetCategoryCursorAllFieldsAndConnections(db, categoryName, flags)) { // You can create a cursor with all fields including connections by just // supplying CmcOptionFlags.All. // However, when the cursor is read, connected items are returned as comma-delimited strng, // which, because Commence does not supply text-qualifiers, makes it impossible to split them. // We therefore explicitly set the connections which deteriorates performance // but gains us (more) reliability. ExportCursor(cur, fileName, this.Settings); } } } }
/// <summary> /// Transforms an image to add a watermark. /// </summary> /// <param name="input"></param> /// <param name="output"></param> /// <param name="waterMarkText"></param> public async Task TransformDownloadImage(string input, Stream output, IExportSettings config) { Logging.Log($" Running image transform for Watermark: {config.WatermarkText}"); using var img = Image.Load(input, out IImageFormat fmt); if (config.Size != ExportSize.FullRes) { int maxSize = config.MaxImageSize; var opts = new ResizeOptions { Mode = ResizeMode.Max, Size = new Size { Height = maxSize, Width = maxSize }, Sampler = KnownResamplers.Lanczos3 }; // Rotate and resize. img.Mutate(x => x.AutoOrient().Resize(opts)); } else { // Just rotate. img.Mutate(x => x.AutoOrient()); } if (!string.IsNullOrEmpty(config.WatermarkText) && fontCollection != null) { // Apply the watermark if one's been specified. var fontFamily = fontCollection.Get("Arial"); var font = fontFamily.CreateFont(10); img.Mutate(context => ApplyWaterMark(context, font, config.WatermarkText, Color.White)); } await img.SaveAsync(output, fmt); }
private int BalanceNumRowsAndFieldSize(IExportSettings settings) { /* If the maxfieldsize is very large, decrease the number of rows being read. * This is largely untested. */ int maxpower = 20; int threshold = (int)Math.Pow(2, maxpower); int i = 10; if (threshold < settings.MaxFieldSize) { while (Math.Pow(2, maxpower) < settings.MaxFieldSize) { i--; maxpower++; if (i == 0) { break; } } } return(i); }
public ExportModel(JiraTimer timer, TimeSpan?exportTime, IExportSettings exportSettings) { UpdateTimer(timer, exportTime); ExportDate = timer.DateStarted.Date != DateTime.Now.Date ? timer.DateStarted.Date.AddHours(12) : DateTime.Now; switch (exportSettings.DefaultRemainingValue) { case DefaultRemaining.Auto: WorkLogStrategy = WorkLogStrategy.Automatic; break; case DefaultRemaining.Leave: WorkLogStrategy = WorkLogStrategy.LeaveRemaining; break; case DefaultRemaining.Set: WorkLogStrategy = WorkLogStrategy.SetValue; break; } DefaultComment = exportSettings.EmptyExportComment; }
internal ExcelWriterUsingOleDb(ICommenceCursor cursor, IExportSettings settings) : base(cursor, settings) { columnDefinitions = new List <ColumnDefinition>(_settings.UseThids ? base.ColumnDefinitions.Skip(1) : base.ColumnDefinitions); }
internal JiraTimerCollection(IExportSettings exportSettings) { this.exportSettings = exportSettings; timerList = JiraTimerCollectionSerializer.DeSerialize(); }
/////////////////////////////////////////////////////////////////////// //public string getFilePath() //{ // object tmp = LightFieldApplication.Experiment.GetValue(ExperimentSettings.FileNameGenerationFileFormatLocation); // if (tmp == null) // { // return "Null object"; // } // else // { // return tmp.ToString(); // } //} /////////////////////////////////////////////////////////////////////// private void Export_Tiff(string sourceFilename) { // Get the file manager IFileManager fm = LightFieldApplication.FileManager; // Block User Pop Ups LightFieldApplication.UserInteractionManager.SuppressUserInteraction = true; try { // Add Files List <string> itemsForExport = new List <string>(); itemsForExport.Add(sourceFilename); IList <IExportSelectionError> selectedErrors = new List <IExportSelectionError>(); ITiffExportSettings tifSettings = (ITiffExportSettings)fm.CreateExportSettings(ExportFileType.Tiff); // Specifics tifSettings.IncludeAllExperimentInformation = true; IExportSettings baseSettings_ = null; baseSettings_ = tifSettings; ExportOutputPathOption options_ = ExportOutputPathOption.InputPath; // Common Settings for all types // baseSettings_.CustomOutputPath = customPath_; baseSettings_.OutputPathOption = options_; baseSettings_.OutputMode = (ExportOutputMode)Enum.Parse(typeof(ExportOutputMode), "OneFilePerFrame"); selectedErrors = baseSettings_.Validate(itemsForExport); // Busy cursor during write using (new AddInStatusHelper(LightFieldApplication, ApplicationBusyStatus.Busy)) { fm.Export(baseSettings_, itemsForExport); } //// Async Mode //if (AsyncCheckBox.IsChecked == true) //{ // fm.ExportCompleted += new EventHandler<ExportCompletedEventArgs>(fm_ExportCompleted); // application_.UserInteractionManager.ApplicationBusyStatus = ApplicationBusyStatus.Busy; // fm.ExportAsync(baseSettings_, itemsForExport); // // Enable cancel // CancelButton.IsEnabled = true; // ExportButton.IsEnabled = false; //} //// Sync Mode //else //{ // ExportButton.IsEnabled = false; // // Busy cursor during write // using (new AddInStatusHelper(LightFieldApplication, ApplicationBusyStatus.Busy)) // { // fm.Export(baseSettings_, itemsForExport); // } // ExportButton.IsEnabled = true; //} } finally { LightFieldApplication.UserInteractionManager.SuppressUserInteraction = false; } }
public void ReConnect(IJiraConnectionSettings newJiraConnectionSettings, IExportSettings newExportSettings) { exportSettings = newExportSettings; jiraConnectionSettings = newJiraConnectionSettings; jira = null; CheckAndConnectJira(); UpdateJiraProjectCache(); }
internal void UpdateAppSettings(IExportSettings newExportSettings) { exportSettings = newExportSettings; }
/// <summary> /// Converts regular Commence value to its canonical representation. /// </summary> /// <remarks>Commence can return canonical values, but only from direct fields. /// This will convert all values to their canonical representation. /// </remarks> /// <param name="value">regular Commence value.</param> /// <param name="fieldType">Commence fieldtype.</param> /// <param name="settings">Settings.</param> /// <returns>string.</returns> internal static string ToCanonical(string value, Vovin.CmcLibNet.Database.CommenceFieldType fieldType, IExportSettings settings) { // Assumes we get a value from Commence, *not* some random string value. // The Commence value will be formatted according to system regional settings, // because that is the format Commence will display and return them. // We take advantage of that in TryParse to the proper .NET data type, // then we deconstruct that data type to return a string in canonical format. if (string.IsNullOrEmpty(value)) { return(value); } string retval = value; bool isCurrency = false; string curSymbol = CultureInfo.CurrentCulture.NumberFormat.CurrencySymbol; decimal number; switch (fieldType) { case CommenceFieldType.Sequence: if (decimal.TryParse(retval, out number)) { retval = Math.Truncate(number).ToString(); } ; break; case CommenceFieldType.Calculation: case CommenceFieldType.Number: // should return xxxx.yy // if Commence was set to "Display as currency" value will be preceded by the system currency symbol // This setting cannot be gotten from Commence, we have to resolve it at runtime. string numPart = retval; if (numPart.Contains(curSymbol)) { isCurrency = true; } numPart = RemoveCurrencySymbol(numPart); // try to cast if (decimal.TryParse(numPart, out number)) { long longPart = (long)Math.Truncate(number); // may fail if number is bigger than long. int decPart; decPart = (int)((Math.Abs(number) - Math.Abs(longPart)) * 100); if (isCurrency && !settings.RemoveCurrencySymbol) { retval = longPart < 0 ? minusSymbol + CanonicalCurrencySymbol + Math.Abs(longPart).ToString() + '.' + decPart.ToString("D2") : CanonicalCurrencySymbol + longPart.ToString() + '.' + decPart.ToString("D2"); } else { retval = longPart.ToString() + '.' + decPart.ToString("D2"); } } break; case CommenceFieldType.Date: // should return yyyymmdd DateTime date; if (DateTime.TryParse(value, out date)) { if (settings.ISO8601Format) { retval = ToIso8601(date, fieldType); } else { retval = date.Year.ToString("D4") + date.Month.ToString("D2") + date.Day.ToString("D2"); } } break; case CommenceFieldType.Time: // should return hh:mm DateTime time; if (DateTime.TryParse(value, out time)) { if (settings.ISO8601Format) { retval = ToIso8601(time, fieldType); } else { retval = time.Hour.ToString("D2") + ':' + time.Minute.ToString("D2"); } } break; case CommenceFieldType.Checkbox: // should return 'true' or 'false' (lowercase) // direct checkbox fields are returned as 'TRUE' or 'FALSE' if (value.Equals("TRUE") || value.Equals("FALSE")) { retval = value.ToLower(); // all OK } else { // related checkbox fields return 'Yes' or 'No' retval = (value.ToLower() == "yes").ToString().ToLower(); } break; } return(retval); }
internal JiraTimerCollection(IExportSettings exportSettings, ITrackUsage trackUsage) { this.exportSettings = exportSettings; this.trackUsage = trackUsage; timerList = JiraTimerCollectionSerializer.DeSerialize(); }
internal DataSetSerializer(DataSet dataset, string fileName, IExportSettings settings) { _ds = dataset; _settings = settings; _filename = fileName; }