public void Copy_to_clipboard() { var grid = new DataGrid { CanUserAddRows = false, Columns = { new DataGridTextColumn { Binding = new Binding("ProductSynonym"), Header = "Наименование", }, new DataGridTextColumn { Binding = new Binding("Cost"), Header = "Цена" } } }; grid.ItemsSource = new List <Offer> { new Offer(new Price("тест"), 100) { ProductSynonym = "Тестовый продукт" }, new Offer(new Price("тест"), 150) { ProductSynonym = "Тестовый продукт 2" }, }; Persistable.CopyToClipboard(grid); var content = Clipboard.GetText(); Assert.AreEqual("Наименование\tЦена\r\nТестовый продукт\t100\r\nТестовый продукт 2\t150\r\n", content); }
public override void Merge(Persistable another) { CreationDate = ((Contract)another).CreationDate; Description = ((Contract)another).Description; Value = ((Contract)another).Value; IsCounted = ((Contract)another).IsCounted; }
private void DeleteClick(object sender, EventArgs e) { TableUtility tableUtility = new TableUtility(); Persistable objectToDelete = currentDataGridView.Rows[currentRowIndex].DataBoundItem as Persistable; currentDataGridView.Rows.RemoveAt(currentRowIndex); tableUtility.DeleteTableRow(objectToDelete); }
private void DeleteClick(object sender, EventArgs e) { TableUtility tableUtility = new TableUtility(Globals.WatchdogAddIn.Application.ActiveWorkbook); Persistable objectToDelete = currentDataGridView.Rows[currentRowIndex].DataBoundItem as Persistable; currentDataGridView.Rows.RemoveAt(currentRowIndex); tableUtility.DeleteTableRow(objectToDelete, objectToDelete.GetIndex()); }
public void Register(Persistable obj) { if (obj == null) { throw new ArgumentNullException(nameof(obj)); } mObjects.AddOrUpdate(new StringKey(obj.Key), obj); }
/// <summary> /// Binds an <see cref="Persistable"/> object to a <see cref="Control"/> /// </summary> /// <param name="control">Control to be bound</param> /// <param name="bindingObject">Object to bind</param> /// <returns>Control with bound object</returns> public static Control BindObjectToControl(Control control, Persistable bindingObject) { if (bindingObject != null) { Binding binding = new Binding(string.Empty, bindingObject, string.Empty); control.DataBindings.Add(binding); } return(control); }
public override void Merge(Persistable another) { CreationDate = ((WorkRecord)another).CreationDate; HourlyRate = ((WorkRecord)another).HourlyRate; MinutesWorked = ((WorkRecord)another).MinutesWorked; WorkStartDate = ((WorkRecord)another).WorkStartDate; Description = ((WorkRecord)another).Description; IsBonus = ((WorkRecord)another).IsBonus; }
private void DeleteFundClick(object sender, EventArgs e) { TableUtility tableUtility = new TableUtility(); DataGridViewRow selectedRow = dataGridFunds.SelectedRows[0]; Persistable objectToDelete = selectedRow.DataBoundItem as Persistable; dataGridFunds.Rows.RemoveAt(selectedRow.Index); tableUtility.DeleteTableRow(objectToDelete); }
public Workbook CreateMissingTable(Persistable persistable) { if (FindWorksheet(persistable.GetTableName()) != null) { return(workbook); } CreateWorksheet(persistable); InsertRowCounter(persistable); return(workbook); }
/// <summary> /// Checks if the class of the passed object is a subclass. /// </summary> /// <param name="persistable"><see cref="Persistable"/> default object</param> /// <returns>If subclass, then it returns the table name, else an empty string</returns> private string IsJoinedTable(Persistable persistable) { if (Attribute.GetCustomAttribute(persistable.GetType(), typeof(JoinedTable), false) is JoinedTable attribute) { if (persistable.GetType().IsGenericType) { return(persistable.GetTableName()); } return(attribute.Name); } return(""); }
/// <summary> /// Gets object type based on the table name. /// The table names will be cross checked with a subset of types. /// </summary> /// <param name="types">Types for cross check</param> /// <param name="tableName">Table name</param> /// <returns>Found type</returns> private Type GetTypeByTableName(Type[] types, string tableName) { foreach (Type type in types) { Persistable persistable = Activator.CreateInstance(type) as Persistable; string objTableName = IsJoinedTable(persistable); if (objTableName.Equals(tableName)) { return(type); } } return(null); }
private int InsertRowCounter(Persistable persistable) { Worksheet ws = FindWorksheet(sequenceTableName); if (ws == null) { ws = CreateSequenceTable(); } int emptyColumn = FindFirstEmtpyColumn(sequenceTableName); ws.Cells[1, emptyColumn].Value = persistable.GetTableName(); ws.Cells[2, emptyColumn].Value = 1; return(emptyColumn); }
/// <summary> /// Gets a list of properties, which are marked with the specified attribute. /// </summary> /// <param name="persistable">Object to check (can be default object)</param> /// <param name="attributeType">Type of the marking attribute</param> /// <returns></returns> private List <PropertyInfo> GetPropertiesByAttribute(Persistable persistable, Type attributeType) { PropertyInfo[] properties = persistable.GetType().GetProperties(); List <PropertyInfo> multiValueProperties = new List <PropertyInfo>(); foreach (PropertyInfo property in properties) { if (property.GetCustomAttributes(attributeType, false).Length != 0) { multiValueProperties.Add(property); } } return(multiValueProperties); }
public virtual void write(Persistable p) { lock (wrapper) { wrapper.Data = p; if (wrapper is IMetaData) { storage.write(new FauxIndexedPersistable(p, wrapper, (IMetaData)wrapper)); } else { storage.write(new FauxIndexedPersistable(p, wrapper)); } } }
/// <summary> /// Refreshes an table row with the actual object data. /// </summary> /// <param name="persistable">Persisted object</param> /// <param name="row">Row with the new data</param> /// <returns><code>True</code> if update is successful, else <code>false</code></returns> private bool ReplaceRange(Persistable persistable, Range row) { string tableName = IsJoinedTable(persistable); if (tableName == "") { tableName = persistable.GetTableName(); } if (row.Worksheet.Name != tableName) { return(false); } int colCounter = 2; List <PropertyInfo> properties = SortPersistableFieldList(GetPropertiesByAttribute(persistable, typeof(PersistableField))); foreach (PropertyInfo property in properties) { Type propertyType = property.PropertyType; if (!propertyType.IsPrimitive && propertyType != typeof(string) && !propertyType.IsEnum) { MultiValue multiValueProperty = property.GetCustomAttribute <MultiValue>(); if (multiValueProperty != null) { var items = property.GetValue(persistable); string content = ""; foreach (Persistable item in items as IEnumerable <Persistable> ) { if (item.GetIndex() != 0) { content += item.GetIndex() + ";"; } } row.Cells[1, colCounter].Value = content; } else { Persistable nestedObject = property.GetValue(persistable) as Persistable; row.Cells[1, colCounter].Value = nestedObject.GetIndex(); } } else { row.Cells[1, colCounter].Value = property.GetValue(persistable); } colCounter++; } return(true); }
private double ChangeRowCounter(Persistable persistable, bool decrement) { int column = FindOrCreateRowCounterColumn(persistable); Worksheet ws = FindWorksheet(sequenceTableName); double counter = ws.Cells[2, column].Value; if (decrement) { counter--; } else { counter++; } ws.Cells[2, column].Value = counter; return(counter); }
public bool Save() { try { var persistable = Persistable.ToArray(); if (string.IsNullOrWhiteSpace(ToolboxApp.Project.State.ProjectFolder)) { OnRecreateMenuItems(new RecreateMenuItemsEventArgs(persistable)); return(false); } var proj = new XenProjectFile(_fs); var loaded = proj.Load(ToolboxApp.Project.State.XenProjectFilePath); if (!loaded) { ToolboxApp.Log.Info($"Creating new project file: {ToolboxApp.Project.State.XenProjectFilePath}."); proj.Schema = XenFormsEnvironment.ProjectFileSchema; } proj.Views = persistable; proj.Save(ToolboxApp.Project.State.XenProjectFilePath); foreach (var pv in proj.Views) { pv.Persisted = true; } OnRecreateMenuItems(new RecreateMenuItemsEventArgs(proj.Views)); return(true); } catch (Exception ex) { ToolboxApp.Log.Error(ex, $"Error saving file: {ToolboxApp.Project.State.XenProjectFilePath}."); MessageBox.Show(Application.Instance.MainForm, "There was an error saving the project file. Please check the log for more information.", "XenForms", MessageBoxButtons.OK, MessageBoxType.Error); return(false); } }
public void CollectionPerformanceTest() { var p = new Persistable<People>(Path); Stopwatch watch = new Stopwatch(); watch.Start(); for (int i = 0; i < 1000; i++) { p.Value.Persons.Add(new Person { FirstName = "Velio", LastName = "Ivanov", Age = 40 }); p.Save(); } watch.Stop(); Console.Out.WriteLine(string.Format("Time elapsed: {0}", watch.Elapsed)); }
private Label GenerateLabel(string text, Persistable bindingObject) { Padding padding = Padding.Empty; Padding margin = new Padding(1, 0, 0, 1); Label label = new Label { Text = text, Width = 150, Height = 50, Margin = margin, Padding = padding, BackColor = Color.White, TextAlign = ContentAlignment.MiddleRight, Font = new Font(Font, Font.Style | FontStyle.Bold) }; FormUtility.BindObjectToControl(label, bindingObject); return(label); }
/// <summary> /// Checks if there is already an exisiting table (<see cref="Worksheet"/>) according to the object, which needs to persisted. /// If not, a table will be created. /// </summary> /// <param name="persistable"><see cref="Persistable"/> default object</param> public void CreateTable(Persistable persistable) { string joinedTable = IsJoinedTable(persistable); Worksheet ws; if (joinedTable != "") { ws = FindWorksheet(joinedTable); } else { ws = FindWorksheet(persistable.GetTableName()); } if (ws != null) { return; } CreateTableWorksheet(persistable); }
/// <summary> /// Persists a new object. /// The index will be set as well. /// </summary> /// <param name="persistable">Object to be persisted</param> /// <returns>Index of the object</returns> public double InsertTableRow(Persistable persistable) { string tableName = IsJoinedTable(persistable); if (tableName == "") { tableName = persistable.GetTableName(); } double row = ChangeRowCounter(tableName, false); double sequence = IncrementSequence(); persistable.SetIndex(sequence); Worksheet ws = FindWorksheet(tableName); ws.Cells[row, 1].Value = sequence; Range rowToInsert = ws.Rows[row]; ReplaceRange(persistable, rowToInsert); return(sequence); }
/// <summary> /// Gets the table row of the specified object based on its index. /// </summary> /// <param name="persistable"><see cref="Persistable"/> object</param> /// <returns>Table row</returns> public Range ReadTableRow(Persistable persistable) { string joinedTable = IsJoinedTable(persistable); Worksheet worksheet; if (joinedTable != "") { worksheet = FindWorksheet(joinedTable); } else { worksheet = FindWorksheet(persistable.GetTableName()); } int rowIndex = BinarySearchTable(persistable); if (rowIndex < 0) { return(null); } return(worksheet.UsedRange.Rows[rowIndex]); }
/// <summary> /// Gets all the rows of a certain table. /// If the type is a base class, the tables of the subclasses will also /// be taken into account. /// </summary> /// <param name="persistable"><see cref="Persistable"/> object</param> /// <returns>List of all ranges</returns> public List <Range> ReadAllRows(Persistable persistable) { List <Range> searchResult = new List <Range>(); bool isJoinedTableBaseClass = IsJoinedTableBaseClass(persistable.GetType()); if (isJoinedTableBaseClass) { Type[] derivedTypes = JoinedTableBaseClassGetSubClasses(persistable.GetType()); foreach (Type derivedType in derivedTypes) { List <Range> subList = ReadAllRows(GetDefaultObject(derivedType)); searchResult.AddRange(subList); } } string joinedTable = IsJoinedTable(persistable); Worksheet worksheet; if (joinedTable != "") { worksheet = FindWorksheet(joinedTable); } else { worksheet = FindWorksheet(persistable.GetTableName()); } if (worksheet == null) { return(searchResult); } Range rows = worksheet.UsedRange.Rows; for (int index = 2; index < rows.Count + 1; index++) { searchResult.Add(rows[index]); } return(searchResult); }
/// <summary> /// Binary search implementation for finding the table row based on the object index. /// </summary> /// <param name="persistable"></param> /// <returns></returns> private int BinarySearchTable(Persistable persistable) { string joinedTable = IsJoinedTable(persistable); Worksheet worksheet; if (joinedTable != "") { worksheet = FindWorksheet(joinedTable); } else { worksheet = FindWorksheet(persistable.GetTableName()); } Range firstColumn = worksheet.UsedRange.Columns[1]; int left = 2, right = firstColumn.Cells.Count, mid; double target = persistable.GetIndex(); while (left <= right) { mid = left + (right - left) / 2; double cellValue = worksheet.Cells[mid, 1].Value; if (target == cellValue) { return(mid); } if (target < cellValue) { right = mid - 1; } else { left = mid + 1; } } return(-1); }
private int FindOrCreateRowCounterColumn(Persistable persistable) { Worksheet ws = FindWorksheet(sequenceTableName); if (ws == null) { CreateSequenceTable(); return(InsertRowCounter(persistable)); } int c = 1; while (true) { if (persistable.GetTableName().Equals(ws.Cells[1, c].Value)) { return(c); } if (ws.Cells[1, c].Value == null) { return(-1); } c++; } }
public Workbook InsertTableRow(Persistable persistable, List <string> data) { if (data.Count != persistable.GetTableHeader().Count) { throw new ArgumentException("The data row's length does not match the the number of table columns."); } Worksheet ws = FindWorksheet(persistable.GetTableName()); if (ws == null) { MessageBox.Show("Tabelle existiert nicht."); return(workbook); } double row = ChangeRowCounter(persistable, false); double sequence = IncrementSequence(); ws.Cells[row, 1].Value = sequence; persistable.SetIndex(sequence); for (int i = 0; i < data.Count; i++) { ws.Cells[row, i + 2].Value = data[i]; } return(workbook); }
public override void Merge(Persistable another) { PasswordHash = ((User)another).PasswordHash; Roles = ((User)another).Roles; }
public void remove(Persistable p) { storage.remove(p); }
public override void Merge(Persistable another) { HourlyRate = ((EmployeeDescription)another).HourlyRate; SumMinutesWorked = ((EmployeeDescription)another).SumMinutesWorked; }
public override void Merge(Persistable another) { Login = ((PublicUserInfo)another).Login; Name = ((PublicUserInfo)another).Name; Surname = ((PublicUserInfo)another).Surname; }
public override void Merge(Persistable other) { Date = ((Summary)other).Date; MinutesWorked = ((Summary)other).MinutesWorked; MoneyWorked = ((Summary)other).MoneyWorked; }
public FauxIndexedPersistable(Persistable p, WrappingStorageUtility.SerializationWrapper w) { this.p = p; this.w = w; this.m = null; }
public FauxIndexedPersistable(Persistable p, WrappingStorageUtility.SerializationWrapper w, IMetaData m) { this.p = p; this.w = w; this.m = m; }
/// <summary> /// Searches a table row with search parameters. /// The search parameters have to passed with a dictionary. The keys are the /// column names and the values are the search parameters. /// </summary> /// <param name="persistable"><see cref="Persistable"/>object (to get to the correct table)</param> /// <param name="searchParameters">Search parameters</param> /// <param name="queryOperator"><see cref="QueryOperator"/></param> /// <returns>List with found rows</returns> public List <Range> ReadTableRow(Persistable persistable, Dictionary <string, string> searchParameters, QueryOperator queryOperator) { List <Range> searchResult = new List <Range>(); Worksheet worksheet; string joinedTable = IsJoinedTable(persistable); if (joinedTable != "") { worksheet = FindWorksheet(joinedTable); } else { worksheet = FindWorksheet(persistable.GetTableName()); } List <string> searchKeys = searchParameters.Keys.ToList(); Dictionary <string, double> columnIndizes = new Dictionary <string, double>(); foreach (string key in searchKeys) { double col = FindColumn(worksheet, key); columnIndizes.Add(key, col); } foreach (Range row in worksheet.UsedRange.Rows) { foreach (string key in columnIndizes.Keys.ToList()) { Range rowCell = row.Cells[1, columnIndizes[key]]; if (rowCell.Value == null) { break; } string cellValue = rowCell.Value.ToString(); bool breakIteration = false; bool rowFound = false; switch (queryOperator) { case QueryOperator.AND: if (!cellValue.Equals(searchParameters[key])) { breakIteration = true; } rowFound = true; break; case QueryOperator.OR: if (cellValue.Equals(searchParameters[key])) { searchResult.Add(row); breakIteration = true; } break; } if (breakIteration) { break; } if (rowFound) { searchResult.Add(row); break; } } } return(searchResult); }
/// <summary> /// Creates an instance of the specified type. /// </summary> /// <param name="type">Type</param> /// <returns>Object of type <see cref="Persistable"/></returns> private Persistable GetDefaultObject(Type type) { Persistable persistable = Activator.CreateInstance(type) as Persistable; return(persistable); }