public RelationshipView Render(RelationshipModel source, int dictionaryId) { var result = source.Map <RelationshipModel, RelationshipView>(); result.RelationType = _enumRenderer.Render(source.RelationType); var links = new List <LinkView> { LinkRenderer.Render("GetRelationById", RelTypes.Self, new { id = dictionaryId, relationshipId = source.Id }), LinkRenderer.Render("GetWordById", RelTypes.SourceWord, new { id = dictionaryId, wordId = source.SourceWordId }), LinkRenderer.Render("GetWordById", RelTypes.RelatedWord, new { id = dictionaryId, wordId = source.RelatedWordId }) }; var link = LinkRenderer.ReRoute(source.Links.WithRel(RelTypes.Update)); if (link != null) { links.Add(link); } link = LinkRenderer.ReRoute(source.Links.WithRel(RelTypes.Delete)); if (link != null) { links.Add(link); } result.Links = links; return(result); }
// // GET: /Relationship/Edit/5 public ActionResult Edit(int id) { RelationshipModel model = new RelationshipModel(); model = pro.GetObject(id); return(View(model)); }
/// <summary> /// Create foreign key constraint /// </summary> /// <param name="model">Relationship model</param> public void AddRelationship(RelationshipModel model) { using (IMsSqlMapper mapper = new MsSqlMapper()) { mapper.CreateForeignKey(model.Destination.Title, model.Source.Title, model.Attributes, model.Name, model.UpdateAction, model.DeleteAction); } }
/// <summary> /// Drop foreign key constraint /// </summary> /// <param name="model">Relationship model</param> public void RemoveRelationship(RelationshipModel model) { using (IMapper mapper = new MsSqlMapper()) { mapper.DropForeignKey(model.Destination.Title, model.Name); } }
private Statement GenerateRelationshipStatement(RelationshipModel relationship, NodeContentType sourceType) { StringBuilder builder = new StringBuilder(); Dictionary <string, object> parameters = new Dictionary <string, object>(); // Create the MATCH statement - all statements will be run separately, so we need to match the node each time builder.AppendFormat("MATCH (s:{0} ", sourceType.ToLabelString()).Append("{id: $sId})").AppendLine(); parameters.Add("sId", relationship.SourceId.ToString()); // Create the MERGE statement builder.AppendFormat("MERGE (t:{0} ", relationship.GetNodeLabel()).Append("{id: $tId})").AppendLine(); parameters.Add("tId", relationship.TargetId.ToString()); // If the node is a new addition, if (relationship.IsNewAddition) { // Add the ON CREATE statement builder.Append("ON CREATE SET t.commonName = $tName").AppendLine(); parameters.Add("tName", relationship.TargetName); } // Append the CREATE statement for the relationship builder.AppendFormat("CREATE ({0})-[:Related{1} ", (sourceType == NodeContentType.Media ? "t" : "s"), relationship.GetNodeLabel()) .Append("{roles: $rRoles}]->").AppendFormat("({0})", sourceType == NodeContentType.Media ? "s" : "t"); parameters.Add("rRoles", relationship.Roles); return(new Statement(builder.ToString(), parameters)); }
public ActionResult Create(RelationshipModel model) { int flag; try { // TODO: Add insert logic here if (ModelState.IsValid) { flag = pro.Insert(model); if (flag == 1) { TempData["success"] = "Record Created Successfully !"; return(RedirectToAction("Index")); } else { TempData["message"] = "Value with this name already exists in Records."; return(View(model)); } } else { return(View(model)); } } catch { return(View()); } }
/// <summary> /// List foreign key coninstraints for table /// </summary> /// <param name="table">Name of table</param> /// <param name="tables">Tables in designer</param> /// <returns>Collection of FK constraints</returns> public IEnumerable <RelationshipModel> ReadRelationshipModels(string table, IEnumerable <TableModel> tables) { using (MsSqlMapper mapper = new MsSqlMapper()) { IEnumerable <ForeignKeyDto> keyDtos = mapper.ListForeignKeys(table); var grouped = keyDtos.Where(t => { if (t.PrimaryKeyTable.Equals(table, StringComparison.CurrentCultureIgnoreCase)) { if (tables.Any(s => s.Title.Equals(t.ForeignKeyTable, StringComparison.CurrentCultureIgnoreCase))) { return(true); } } if (t.ForeignKeyTable.Equals(table, StringComparison.CurrentCultureIgnoreCase)) { if (tables.Any(s => s.Title.Equals(t.PrimaryKeyTable, StringComparison.CurrentCultureIgnoreCase))) { return(true); } } return(false); }).GroupBy(t => t.Name); var res = new List <RelationshipModel>(); foreach (IGrouping <string, ForeignKeyDto> dtos in grouped) { var model = new RelationshipModel(); model.Name = dtos.Key; var first = dtos.FirstOrDefault(); model.Source = tables.FirstOrDefault(t => t.Title.Equals(first.PrimaryKeyTable)); model.Destination = tables.FirstOrDefault(t => t.Title.Equals(first.ForeignKeyTable)); foreach (ForeignKeyDto keyDto in dtos) { RowModelPair pair = new RowModelPair(); pair.Source = model.Source.Attributes.FirstOrDefault(t => t.Name.Equals(keyDto.PrimaryKeyCollumn)); pair.Destination = model.Destination.Attributes.FirstOrDefault(t => t.Name.Equals(keyDto.ForeignKeyCollumn)); model.Attributes.Add(pair); } model.Optionality = model.Attributes.All(t => t.Destination.AllowNull) ? Optionality.Optional : Optionality.Mandatory; model.DeleteAction = first.DeleteAction; model.UpdateAction = first.UpdateAction; model.Id = first.Id; model.LastModified = first.LastModified; res.Add(model); } return(res); } }
public ActionResult Index() { RelationshipModel model = new RelationshipModel(); model.RelationshipList = pro.GetList(); return(View(model)); }
/// <summary> /// Generate Alter table statement /// </summary> /// <param name="model">Foreign model</param> /// <returns>Foreign key statement</returns> protected override string GenerateForeignKey(RelationshipModel model) { string sql = @"ALTER TABLE [{0}] ADD CONSTRAINT {1} FOREIGN KEY ({2}) REFERENCES [{3}] ({4}) ON DELETE {5} ON UPDATE {6}"; string tableColumns = string.Join(",", model.Attributes.Select(t => t.Destination.Name)); string referencedColumns = string.Join(",", model.Attributes.Select(t => t.Source.Name)); return(string.Format(sql, GetTableName(model.Destination.Title), model.Name, tableColumns, model.Source.Title, referencedColumns, model.DeleteAction.Replace('_', ' '), model.UpdateAction.Replace('_', ' '))); }
public RelationshipModel GetObject(int id) { using (EHMSEntities ent = new EHMSEntities()) { var obj = ent.SetupRelationships.Where(x => x.RelationId == id).FirstOrDefault(); RelationshipModel model = AutoMapper.Mapper.Map <SetupRelationship, RelationshipModel>(obj); return(model); } }
public void Constructor() { //---------------Set up test pack------------------- //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- var model = new RelationshipModel(RelationshipType.OneToOne, "TestKeyTable", "TestKeyColumn", EqualityOperators.Equals, "TestFkTable", "TestFkColumn"); //---------------Test Result ----------------------- Assert.IsNotNull(model); }
/// <summary> /// Creates a relationship view model from the given relationship model. /// </summary> /// <param name="model">The relationship model</param> /// <returns>The created relationship view model</returns> public static RelationshipViewModel FromModel(RelationshipModel model) { return(new RelationshipViewModel { SourceId = model.SourceId, TargetId = model.TargetId, TargetType = model.TargetType, TargetName = model.TargetName, Roles = model.Roles }); }
public void Update(RelationshipModel model) { using (EHMSEntities ent = new EHMSEntities()) { var objtoedit = ent.SetupRelationships.Where(x => x.RelationId == model.RelationId).FirstOrDefault(); model.CreatedBy = objtoedit.CreatedBy; AutoMapper.Mapper.Map(model, objtoedit); objtoedit.Status = "A"; ent.Entry(objtoedit).State = System.Data.EntityState.Modified; ent.SaveChanges(); } }
/// <summary> /// Add given relationship to diagrram /// </summary> /// <param name="relationship">Relationship</param> /// <param name="canvas">Canvas for relationship add</param> /// <returns>Task for async execution</returns> public async Task AddRelationship(RelationshipModel relationship, DesignerCanvas canvas) { ConnectionInfoViewModel vm = new ConnectionInfoViewModel(); vm.DesignerCanvas = canvas; vm.RelationshipModel = relationship; vm.SourceViewModel = ViewModel.TableViewModels.FirstOrDefault(t => t.Model.Equals(relationship.Source)); vm.DestinationViewModel = ViewModel.TableViewModels.FirstOrDefault(t => t.Model.Equals(relationship.Destination)); await vm.BuildConnection3(ViewModel); ViewModel.ConnectionInfoViewModels.Add(vm); }
/// <summary> /// Generate Alter table statement /// </summary> /// <param name="model">Foreign model</param> /// <returns>Foreign key statement</returns> protected override string GenerateForeignKey(RelationshipModel model) { string sql = @"ALTER TABLE {0} ADD CONSTRAINT {1} FOREIGN KEY ({2}) REFERENCES {3} ({4})"; string tableColumns = string.Join(",", model.Attributes.Select(t => t.Destination.Name)); string referencedColumns = string.Join(",", model.Attributes.Select(t => t.Source.Name)); if (!model.DeleteAction.ToUpper().Equals("NO ACTION")) { sql += $" ON DELETE {model.DeleteAction}"; } return(string.Format(sql, GetTableName(model.Destination.Title), model.Name, tableColumns, GetTableName(model.Source.Title), referencedColumns)); }
/// <summary> /// Create foreign key constraint /// </summary> /// <param name="model">Relationship model</param> /// <returns>Exception message if failed, NULL if not</returns> public string AddRelationship(RelationshipModel model) { var ctx = new DatabaseContext(SessionProvider.Instance.ConnectionType); try { ctx.AddRelationship(model); return(null); } catch (Exception exception) when(exception is SqlException || exception is OracleException) { Output.WriteLine(OutputPanelListener.PrepareException(exception.Message)); return(exception.Message); } }
public void GetHashCode_ShouldReturnStringHashCode() { //---------------Set up test pack------------------- var relationshipModel = new RelationshipModel(RelationshipType.OneToOne, "KeyTable", "KeyColumn", EqualityOperators.Like, "FkTable", "FkColumn") { DatabaseProvider = new SqlServerDatabaseProvider() }; var hashCode = 0; //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- Assert.DoesNotThrow(() => hashCode = relationshipModel.GetHashCode()); //---------------Test Result ----------------------- Assert.IsNotNull(hashCode); }
public void ToString_GivenRelationshipValues_ShouldReturnExpectedStatement(RelationshipType relationshipType, string keyTableName, string keyColumnName, EqualityOperators equalityOperator, string foreignKeyTable, string foreignKeyColumn, string expectedStatement) { //---------------Set up test pack------------------- var relationshipModel = new RelationshipModel(relationshipType, keyTableName, keyColumnName, equalityOperator, foreignKeyTable, foreignKeyColumn) { DatabaseProvider = new SqlServerDatabaseProvider() }; //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- var relationshipTatement = relationshipModel.ToString(); //---------------Test Result ----------------------- Assert.AreEqual(expectedStatement, relationshipTatement); }
public int Insert(RelationshipModel model) { using (EHMSEntities ent = new EHMSEntities()) { if (ent.SetupRelationships.Any(s => s.RelationName == model.RelationName)) { return(0); } var objToSave = AutoMapper.Mapper.Map <RelationshipModel, SetupRelationship>(model); objToSave.Status = "A"; objToSave.CreatedBy = 1; objToSave.CreatedDate = DateTime.Now; ent.SetupRelationships.Add(objToSave); ent.SaveChanges(); return(1); } }
/// <summary> /// Create new /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private async void Confirm_OnExecuted(object sender, ExecutedRoutedEventArgs e) { var isOk = await CheckIntegrity(); if (isOk) { var relModel = new RelationshipModel { Name = RelationshipName, Source = SourceTableVm.Model, Destination = DestinationTableVm.Model }; relModel.Attributes.AddRange(GridData); relModel.Optionality = relModel.Attributes.All(t => t.Destination.AllowNull) ? Optionality.Optional : Optionality.Mandatory; relModel.DeleteAction = OnDeleteComboBox.SelectedValue as string; relModel.UpdateAction = OnUpdateComboBox.SelectedValue as string; var updater = new DatabaseUpdater(); string res = updater.AddRelationship(relModel); if (res != null) { await this.ShowMessageAsync("Add foreign key", res); } else { ConnectionInfoViewModel model = new ConnectionInfoViewModel() { DestinationViewModel = DestinationTableVm, SourceViewModel = SourceTableVm, DesignerCanvas = Canvas }; model.RelationshipModel.RefreshModel(relModel); await model.BuildConnection3(DesignerViewModel); DesignerViewModel.ConnectionInfoViewModels.Add(model); DialogResult = true; Close(); } } }
public void Equals_GivenDifferentRelationshipData_ShouldReturnTrue(RelationshipType relationshipType, string keyTableName, string keyColumnName, EqualityOperators equalityOperator, string foreignKeyTable, string foreignKeyColumn) { //---------------Set up test pack------------------- var relationshipModel = new RelationshipModel(relationshipType, keyTableName, keyColumnName, equalityOperator, foreignKeyTable, foreignKeyColumn) { DatabaseProvider = new SqlServerDatabaseProvider() }; var compareModel = new RelationshipModel(RelationshipType.OneToOne, "OtherKeyTable", "OtherKeyColumn", EqualityOperators.Like, "OtherFkTable", "OtherFkColumn") { DatabaseProvider = new SqlServerDatabaseProvider() }; //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- var equalResult = relationshipModel.Equals(compareModel); //---------------Test Result ----------------------- Assert.IsFalse(equalResult); }
public ActionResult Edit(int id, RelationshipModel model) { try { // TODO: Add update logic here if (ModelState.IsValid) { pro.Update(model); TempData["success"] = "Record Updated Successfully !"; return(RedirectToAction("Index")); } else { return(View(model)); } } catch { return(View()); } }
internal void Update(RelationshipModel model) { Type = model.Type; }
internal CachedRelationship(DiscordClient client, RelationshipModel model) : base(client, model.Id) { User = client.GetOrAddSharedUser(model.User); Update(model); }
/// <summary> /// Compare two given foreign key constraints by values /// </summary> /// <param name="model1">Relationship model</param> /// <param name="model2">Relationship model</param> /// <returns>True if models are the same, false if not</returns> public bool AreRelationshipModelsTheSame(RelationshipModel model1, RelationshipModel model2) { return(_strategy.Comparer.Compare(model1, model2) == 1); }
/// <summary> /// Create foreign key constraint /// </summary> /// <param name="model">Relationship model</param> public void AddRelationship(RelationshipModel model) { _strategy.AddRelationship(model); }
/// <summary> /// Drop foreign key constraint /// </summary> /// <param name="model">Relationship model</param> public void RemoveRelationship(RelationshipModel model) { _strategy.RemoveRelationship(model); }
private FamilyModel GetCurrentFamilyModel() { FamilyModel currentFamilyModel = new FamilyModel(); currentFamilyModel.PersonSettings = Settings.Instance.Person; currentFamilyModel.RelationshipSettings = Settings.Instance.Relationship; currentFamilyModel.Tree = Tree; if (SelectedPerson != null) { currentFamilyModel.Tree.SelectedPersonId = SelectedPerson.Id; } if (SelectedRelationship != null) { currentFamilyModel.Tree.SelectedRelationshipId = SelectedRelationship.Id; } currentFamilyModel.Members = new ObservableCollection<PersonModel>() { }; foreach (PersonView personView in Members) { PersonModel personModel = new PersonModel(); personModel.CopyBaseProperties(personView); currentFamilyModel.Members.Add(personModel); } currentFamilyModel.Relationships = new ObservableCollection<RelationshipModel> { }; foreach (RelationshipView relationshipView in Relationships) { RelationshipModel relationshipModel = new RelationshipModel(); relationshipModel.CopyBaseProperties(relationshipView); currentFamilyModel.Relationships.Add(relationshipModel); } return currentFamilyModel; }
internal RestRelationship(RestDiscordClient client, RelationshipModel model) : base(client, model.Id) { User = new RestUser(client, model.User); Update(model); }
/// <summary> /// Generate Alter table statement /// </summary> /// <param name="model">Foreign model</param> /// <returns>Foreign key statement</returns> protected abstract string GenerateForeignKey(RelationshipModel model);
// // GET: /Relationship/Create public ActionResult Create() { RelationshipModel model = new RelationshipModel(); return(View(model)); }