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