public DataTable LoadParts() { PartsTable = new DataTable(); try { SQLQueryModel queryBuilder = new SQLQueryModel(); string query = string.Format("SELECT partID, partName, price, categoryID FROM part;"); PartsTable = queryBuilder.ExecuteMySQLQuery(query); Parts = new ObservableCollection <PartTable>(); foreach (DataRow row in PartsTable.Rows) { _partTable = new PartTable(); _partTable.PartID = Convert.ToInt32(row["partID"]); _partTable.PartName = row["partName"].ToString(); _partTable.Price = Convert.ToInt32(row["price"]); _partTable.CategoryID = Convert.ToInt32(row["categoryID"]); //_partTable.RequiredPartID = Convert.ToInt32(row["requiredPartID"]); } return(PartsTable); } catch (ArgumentNullException nullex) { return(null); } }
public MainScreen() { InitializeComponent(); PartTable.DataSource = Inventory.AllParts; PartTable.ClearSelection(); ProductTable.DataSource = Inventory.Products; ProductTable.ClearSelection(); }
public void AddRelation <To, ToKeyType>( RelationItemInfo <To, ToKeyType> ThisRelation, Table <To, ToKeyType> .RelationTableInfo <ValueType, KeyType> ThatRelation) where ToKeyType : IComparable <ToKeyType> { #if TRACE Console.WriteLine("@ " + this.GetType().Namespace + this.GetType().Name + " _AddRelation_1_X"); #endif var RelationName = ThisRelation.Link.Body.ToString() + ThatRelation.Link.Body.ToString(); this._AddRelationForLoading(RelationName, ThisRelation); ThisRelation.LinkArray._AddRelationForLoading(RelationName, ThatRelation, Accepted: (Key, AcceptedKey, PartTable) => { #if TRACE Console.WriteLine("@ " + this.GetType().Namespace + this.GetType().Name + " _AddRelation_1_X >> Accepted"); #endif using (ThisRelation.LinkArray.IgnoreUpdateAble.Block()) { PartTable.SaveToParent(); } using (this.IgnoreUpdateAble.Block()) { this.Update(AcceptedKey, (c) => ThisRelation.Field.Value(c, (f) => { f.Key = Key; return(f); })); } }, Ignored: (Key, IgnoredKey, PartTable) => { #if TRACE Console.WriteLine("@ " + this.GetType().Namespace + this.GetType().Name + " _AddRelation_1_X >> Ignored"); #endif using (ThisRelation.LinkArray.IgnoreUpdateAble.Block()) { PartTable.SaveToParent(); } using (this.IgnoreUpdateAble.Block()) { if (this.PositionOf(IgnoredKey) > -1) { this.Update(IgnoredKey, (c) => ThisRelation.Field.Value(c, (f) => { f.Key = null; return(f); })); } } }, MakeNew: (c) => { ThisRelation.Field.Value(c.NewValue, (f) => { f.Key = ThatRelation.OwnerArray.GetKey(c.LoadedValue); return(f); }); }); this.KeyChanged += (info) => { #if TRACE Console.WriteLine("@ " + this.GetType().Namespace + this.GetType().Name + " _AddRelation_1_X >> KeyChanged"); #endif if (Run.Use(RelationName)) { using (ThisRelation.LinkArray.IgnoreUpdateAble.Block()) { var ThisRelationArray = ThisRelation.Field.Value(info.Value); if (ThisRelationArray.Key != null) { ThisRelation.LinkArray.Update((ToKeyType)ThisRelationArray.Key, (c) => { ThatRelation.Field.Value(c).Ignore(info.OldKey); ThatRelation.Field.Value(c).Accept(info.NewKey); }); } } } }; ThisRelation.LinkArray.KeyChanged += (info) => { #if TRACE Console.WriteLine("@ " + this.GetType().Namespace + this.GetType().Name + " _AddRelation_1_X >> KeyChanged"); #endif if (Run.Use(RelationName)) { using (this.IgnoreUpdateAble.Block()) { var ThatRelation_array = ThatRelation.Field.Value(info.Value); for (int i = 0; i < ThatRelation_array.KeysInfo.Keys.Length; i++) { var ThisValue = ThatRelation_array[i]; var Key = this.GetKey(ThisValue); ThisRelation.Field.Value(ThisValue.Value, (f) => { f.Key = info.NewKey; return(f); }); ThisRelation.Field.Value(ThisValue.Value, (f) => { f.OldKey = info.NewKey; return(f); }); this.Update(Key, ThisValue); } } } }; this.Events.Deleted += (Info) => { #if TRACE Console.WriteLine("@ " + this.GetType().Namespace + this.GetType().Name + " _AddRelation_1_X >> Deleted"); #endif if (Run.Use(RelationName)) { using (ThisRelation.LinkArray.IgnoreUpdateAble.Block()) { var ThisRelationArray = ThisRelation.Field.Value(Info.Value); if (ThisRelationArray.Key != null) { ThisRelation.LinkArray.Update((ToKeyType)ThisRelationArray.Key, (c) => { ThatRelation.Field.Value(c).Ignore((KeyType)Info.Info[KeyPos].Key); }); } } } }; if (ThisRelation.IsChild) { ThisRelation.LinkArray.Events.Deleted += (info) => { #if TRACE Console.WriteLine("@ " + this.GetType().Namespace + this.GetType().Name + " _AddRelation_1_X >> Deleted IsChild"); #endif if (Run.Use(RelationName)) { var ThatRelation_array = ThatRelation.Field.Value(info.Value); foreach (var ThisKey in ThatRelation_array.KeysInfo.Keys) { this.Delete(ThisKey); } } }; } else { ThisRelation.LinkArray.Events.Deleted += (info) => { #if TRACE Console.WriteLine("@ " + this.GetType().Namespace + this.GetType().Name + " _AddRelation_1_X >> Deleted"); #endif if (Run.Use(RelationName)) { var ThatRelation_array = ThatRelation.Field.Value(info.Value); for (int i = 0; i < ThatRelation_array.KeysInfo.Keys.Length; i++) { var ThisValue = ThatRelation_array[i]; var Key = this.GetKey(ThisValue); ThisRelation.Field.Value(ThisValue.Value, (f) => { f.Key = null; return(f); }); this.Update(Key, ThisValue); } } }; } Action <(ValueType Value, Events <ValueType> .ValueInfo[] Info)> OnSave = (Value) => { #if TRACE Console.WriteLine("@ " + this.GetType().Namespace + this.GetType().Name + " _AddRelation_1_X >> OnSave"); #endif if (Run.Use(RelationName)) { #if TRACE Console.WriteLine(">> var ThisRelationArray = ThisRelation.Field.Value(ref Value.Value);"); #endif var ThisRelationArray = ThisRelation.Field.Value(Value.Value); var Key = ThisRelationArray.Key; var OldKey = ThisRelationArray.OldKey; if (Compare(Key, OldKey) != 0) { var ChangedKey = this.GetKey(Value.Value); if (Key != null) { ThisRelation.LinkArray.Update((ToKeyType)ThisRelationArray.Key, (c) => { #if TRACE Console.WriteLine(">> Key != null"); #endif ThatRelation.Field.Value(c).Accept(ChangedKey); }); } if (OldKey != null) { #if TRACE Console.WriteLine(">> OldKey != null"); #endif ThisRelation.LinkArray.Update((ToKeyType)ThisRelationArray.Key, (c) => { ThatRelation.Field.Value(c).Ignore(ChangedKey); }); } } } }; this.Events.Inserted += (Value) => OnSave(Value); this.Events.Updated += (Value) => OnSave(Value); if (ThatRelation.IsUpdateAble) { this.Events.Updated += (info) => { #if TRACE Console.WriteLine("@ " + this.GetType().Namespace + this.GetType().Name + " _AddRelation_1_X >> Updated"); #endif if (this.IgnoreUpdateAble.BlockLengths == 0) { var ThatValue = ThisRelation.Field.Value(info.Value); if (ThatValue.Key != null) { if (Run.Use(RelationName + "UP")) { using (ThisRelation.LinkArray.IgnoreUpdateAble.Block()) { ThisRelation.LinkArray.Update(ThatValue, (c) => { var MyInfo = info.Info[KeyPos]; ThatRelation.Field.Value(c).UpdateAble.Changed( (KeyType)MyInfo.OldKey, (KeyType)MyInfo.OldKey); }); } } } } }; } ThisRelation.LinkArray.Events.Saving += (Value) => { }; if (ThatRelation.ClearRelationOnSendUpdate) { ThisRelation.LinkArray._ClearRelation(ThatRelation.Link); } ThisRelation.OwnerArray._MoveRelations(ThisRelation.Link); }
private void _AddRelation <To, ToKeyType>( string RelationName, RelationTableInfo <To, ToKeyType> ThisRelation, Table <To, ToKeyType> .RelationTableInfo <ValueType, KeyType> ThatRelation) where ToKeyType : IComparable <ToKeyType> { #if TRACE Console.WriteLine("@ " + this.GetType().Namespace + this.GetType().Name + " _AddRelation_X_X"); #endif _AddRelationForLoading(RelationName, ThisRelation, Accepted: (Key, AcceptedKey, PartTable) => { #if TRACE Console.WriteLine("@ " + this.GetType().Namespace + this.GetType().Name + " _AddRelation_X_X >> Accepted"); #endif using (this.IgnoreUpdateAble.UseBlock()) { PartTable.SaveToParent(); } using (ThisRelation.LinkArray.IgnoreUpdateAble.UseBlock()) { ThisRelation.LinkArray.Update(AcceptedKey, (c) => ThatRelation.Field.Value(c).Accept(Key)); } }, Ignored: (Key, IgnoredKey, PartTable) => { #if TRACE Console.WriteLine("@ " + this.GetType().Namespace + this.GetType().Name + " _AddRelation_X_X >> Ignored"); #endif using (this.IgnoreUpdateAble.UseBlock()) { PartTable.SaveToParent(); } using (ThisRelation.LinkArray.IgnoreUpdateAble.UseBlock()) { ThisRelation.LinkArray.Update(IgnoredKey, (c) => (ThatRelation.Field.Value(c)).Ignore(Key)); } }); this.KeyChanged += (info) => { #if TRACE Console.WriteLine("@ " + this.GetType().Namespace + this.GetType().Name + " _AddRelation_X_X >> KeyChanged"); #endif if (Run.Use(RelationName)) { using (ThisRelation.LinkArray.IgnoreUpdateAble.UseBlock()) { var ThisValue = ThisRelation.Field.Value(info.Value); foreach (var ThatValue in ThisValue) { var ThatRelationTbl = ThatRelation.Field.Value(ThatValue); ThatRelationTbl.KeysInfo.Keys.BinaryDelete(info.OldKey); ThatRelationTbl.KeysInfo.Keys.BinaryInsert(info.NewKey); ThisRelation.LinkArray.Update(ThatValue); } } } }; this.Events.Deleted += (info) => { #if TRACE Console.WriteLine("@ " + this.GetType().Namespace + this.GetType().Name + " _AddRelation_X_X >> Deleted"); #endif if (Run.Use(RelationName)) { using (ThisRelation.LinkArray.IgnoreUpdateAble.UseBlock()) { ThisRelation.LinkArray.Update(ThisRelation.Field.Value(info.Value), (c) => ThatRelation.Field.Value(c).Ignore( (KeyType)info.Info[ThatRelation.Field.Value(c).KeyPos].Key)); } } }; var RelationName_Update = "U" + ThisRelation.Link.ToString() + RelationName; if (ThisRelation.IsUpdateAble) { this.Events.Updated += (info) => { #if TRACE Console.WriteLine("@ " + this.GetType().Namespace + this.GetType().Name + " _AddRelation_X_X >> Updated"); #endif if (this.IgnoreUpdateAble.BlockLengths == 0) { if (Run.Use(RelationName_Update)) { using (ThisRelation.LinkArray.IgnoreUpdateAble.UseBlock()) { var ThisValue = ThisRelation.Field.Value(info.Value); foreach (var ThatValue in ThisValue) { ThisRelation.LinkArray.Update(ThatValue, (c) => { var MyInfo = info.Info[KeyPos]; ThatRelation.Field.Value(c).UpdateAble.Changed( (KeyType)MyInfo.OldKey, (KeyType)MyInfo.OldKey); }); } } } } }; } if (ThisRelation.ClearRelationOnSendUpdate) { this._ClearRelation(ThisRelation.Link); } if (ThatRelation.ClearRelationOnSendUpdate) { ThisRelation.LinkArray._ClearRelation(ThatRelation.Link); } }
public async Task MakeUpdate(ulong ServerLastUpCode) { if (Table.UpdateAble.UpdateCode > ServerLastUpCode) { Table.UpdateAble.Clear(); if (IsPartOfTable) { ParentTable.UpdateAble.Clear(); } } while (StartPos <= EndPos) { await FindLastTrue(); StartPos++; if (StartPos >= ServerItemsCount) { break; } else { var NextUpCode = await GetUpdateCodeAtPos(StartPos); DeleteExtraItems(NextUpCode); if (StartPos >= Table.UpdateAble.UpdateCodes.Length) { break; } var MyUpCode = Table.UpdateAble.UpdateCodes[StartPos]; if (MyUpCode.UpdateCode > NextUpCode) { await UpdateFromPosToUpCode(StartPos, MyUpCode.UpdateCode); } } } if (StartPos < ServerItemsCount) { await UpdateFromPosToEnd(StartPos); } else { DeleteItemsFrom(ServerItemsCount); } if (IsPartOfTable) { foreach (var Delete in ShouldDelete) { if (await IsExistAtParent(Delete)) { PartTable.Ignore(Delete); } else { PartTable.Delete(Delete); } } } else { foreach (var Delete in ShouldDelete) { Table.Delete(Delete); } } Table.UpdateAble.UpdateCode.Save(ServerLastUpCode); if (IsPartOfTable) { PartTable.SaveToParent(); } #if DEBUG_UpdateAble await Debuger(); #endif }
private async Task UpdateNextItems() { var Len = await Client.GetData <int>(); var ServerUpCodes = new ulong[Len]; ulong[] ServerUpCodes_Parent = null; if (IsPartOfTable) { ServerUpCodes_Parent = new ulong[Len]; } for (int i = 0; i < Len; i++) { var UpCode = await Client.GetData <ulong>(); if (IsPartOfTable) { var ParentUpCode = await Client.GetData <ulong>(); if (ParentTable.UpdateAble.IsExist(ParentUpCode)) { var ParentUpDate = ParentTable.UpdateAble[ParentUpCode]; if (PartTable.IsExist(ParentUpDate.Key) == false) { PartTable.Accept(ParentUpDate.Key); } Added(ParentUpDate.Key, UpCode); await Client.SendData(false); StartPos++; Len--; i--; } else { await Client.SendData(true); ServerUpCodes[i] = UpCode; ServerUpCodes_Parent[i] = ParentUpCode; } } else { await Client.SendData(true); ServerUpCodes[i] = UpCode; } } for (int i = 0; i < Len; i++) { var Value = await Client.GetData <ValueType>(); var Key = Table.GetKey(Value); var Update = new UpdateAble <KeyType>() { Key = Key, UpdateCode = ServerUpCodes[i] }; Table.UpdateOrInsert(Key, (c) => { Table.MoveRelations(c, Value); return(Value); }); if (IsPartOfTable) { Added(Key, ServerUpCodes[i], ServerUpCodes_Parent[i]); } else { Added(Key, ServerUpCodes[i]); } StartPos++; } }
public Log GetLog(PartTable parts, LocaleTable locales) { return new Log(new Qualifier.Unique(parts.GetPart(PartId), locales.GetLocale(LocaleId), Key), Date); }
public void Reload() { using (var connector = Connect()) { var connection = connector.Connection; var server = GetServer(connection); var database = GetDatabase(server); if (!database.Schemas.Contains(_tableConfiguration.Schema)) { var schema = new Schema(database, _tableConfiguration.Schema); database.Schemas.Add(schema); schema.Create(); } _partTable = new PartTable(connection, database, _tableConfiguration); _localeTable = new LocaleTable(connection, database, _tableConfiguration); _valueTable = new ValueTable(connection, database, _tableConfiguration); _logTable = new LogTable(database, _tableConfiguration); } }
public DBValue GetValue(PartTable.DBPart part, LocaleTable.DBLocale locale, String key) { try { return _valuesByQualifier[new InternalQualifier(part.Id, locale.Id, key)]; } catch(KeyNotFoundException) { var parent = part.Parent as PartTable.DBPart; if (parent != null) return GetValue(parent, locale, key); } return null; }
public IEnumerable<QualifiedValue> GetQualifiedValues(PartTable partTable, LocaleTable localeTable) { return _valuesByQualifier .Select(qv => new QualifiedValue( new Qualifier.Unique( partTable.GetPart(qv.Key.PartId), localeTable.GetLocale(qv.Key.LocaleId), qv.Key.Key ), qv.Value.Content )).ToList(); }