public T CreateEntity <T>(int entityTypeId) where T : CFEntity, new()
{
CFEntityType et = Db.EntityTypes.Where(t => t.Id == entityTypeId).FirstOrDefault();
if (et == null)
{
throw new Exception("EntityType with ID " + entityTypeId + " not found");
}
T entity = new T();
entity.EntityType = et;
entity.EntityTypeId = et.Id;
entity.InitMetadataSet(et.MetadataSets.ToList());
entity.SetAttribute("entity-type", et.Name);
//removing audit trail entry that was created when creating the metadata set originally
foreach (CFMetadataSet ms in entity.MetadataSets)
{
XElement audit = ms.Data.Element("audit");
if (audit != null)
{
audit.Remove();
}
}
return(entity);
}
public void CreateItems()
{
int COUNT = 50;
CatfishDbContext db = new CatfishDbContext();
List <CFEntityType> itemTypes = db.EntityTypes.Where(t => t.TargetTypes.Contains(CFEntityType.eTarget.Items.ToString())).ToList(); //db.EntityTypes.Where(t => t.TargetType == EntityType.eTarget.Items).ToList();
if (itemTypes.Count == 0)
{
throw new Exception("No entity types have been defined for collections.");
}
var rand = new Random();
ItemService srv = new ItemService(db);
for (int i = 0; i < COUNT; ++i)
{
CFEntityType cType = itemTypes[rand.Next(0, itemTypes.Count)];
CFItem c = srv.CreateEntity <CFItem>(cType.Id);
string name = TestData.LoremIpsum(5, 10);
c.SetDescription(TestData.LoremIpsum(20, 100, 1, 10));
c.SetName("Item: " + name);
c.Serialize();
db.Items.Add(c);
}
db.SaveChanges();
}
public void UpdateExistingEntityMetadataTest()
{
const string metadataName = "UpdateExistingEntityMetadataTest";
const string metadataDescription = "Test for function UpdateExistingEntityMetadata.";
const string entityTypeName = "UpdateExistingEntityMetadataTest";
const string entityTypeDescription = "Test for function UpdateExistingEntityMetadata.";
// Create an entity
CFMetadataSet metadata = CreateBasicMetadataSet(metadataName, metadataDescription);
CFEntityType entityType = CreateEntityType(mDh, entityTypeName, entityTypeDescription, "Items", metadata);
entityType.AttributeMappings.Add(new CFEntityTypeAttributeMapping()
{
Name = "Name Mapping", MetadataSet = metadata, FieldName = NAME_NAME
});
entityType.AttributeMappings.Add(new CFEntityTypeAttributeMapping()
{
Name = "DescriptionMapping", MetadataSet = metadata, FieldName = NAME_DESCRIPTION
});
mDh.Db.SaveChanges();
CFItem item1 = mDh.CreateItem(mDh.Is, entityType.Id, "Item 1", "Item 1 Description", true);
CFItem item2 = mDh.CreateItem(mDh.Is, entityType.Id, "Item 2", "Item 2 Description", true);
}
public JsonResult Save(EntityTypeViewModel vm)
{
if (ModelState.IsValid)
{
CFEntityType model;
if (vm.Id > 0)
{
model = EntityTypeService.GetEntityTypeById(vm.Id);//Db.EntityTypes.Where(x => x.Id == vm.Id).FirstOrDefault();
if (model == null)
{
return(Json(vm.Error("Specified entity type not found")));
}
else
{
vm.UpdateDataModel(model, Db);
//Db.Entry(model).State = System.Data.Entity.EntityState.Modified;
EntityTypeService.UpdateEntityType(model);
}
}
else
{
model = new CFEntityType();
vm.UpdateDataModel(model, Db);
// Db.EntityTypes.Add(model);
EntityTypeService.UpdateEntityType(model);
}
Db.SaveChanges(User.Identity);
vm.Status = KoBaseViewModel.eStatus.Success;
if (vm.Id == 0)
{
//This is a newly created object, so we ask knockout MVC to redirect it to the edit page
//so that the ID is added to the URL.
vm.redirect = true;
vm.url = Url.Action("Edit", "EntityTypes", new { id = model.Id });
}
}
else
{
if (string.IsNullOrEmpty(vm.Name))
{
vm.ErrorMessage = "*";
}
foreach (var att in vm.AttributeMappings)
{
if (string.IsNullOrEmpty(att.Name) || string.IsNullOrEmpty(att.Field))
{
att.ErrorMessage = "*";
}
}
return(Json(vm.Error("Model validation failed")));
}
return(Json(vm));
}
public T CreateAggregation <T>(CFXmlModel aggregation) where T : CFAggregation, new()
{
T agg = new T();
string entityTypeName = aggregation.Data.Attribute("entity-type").Value;
CFEntityType entType = Db.EntityTypes.Where(e => e.Name == entityTypeName).FirstOrDefault();
agg = (T)aggregation;
agg.EntityType = entType;
return(agg);
}
protected CFEntityType CreateEntityType(DatabaseHelper dh, string name, string description, string targetTypes, params CFMetadataSet[] metadataSets)
{
CFEntityType type = new CFEntityType()
{
Name = name,
Description = description,
MetadataSets = metadataSets,
TargetTypes = targetTypes
};
return(dh.Ets.CreateEntityType(type));
}
public bool DeleteEntityType(CFEntityType entityType)
{
try
{
Db.Entry(entityType).State = EntityState.Deleted;
return(true);
}
catch (Exception ex)
{
throw ex;
}
}
public void CreateEntityType(CFEntityType entityType)
{
Db.EntityTypes.Add(entityType);
foreach (var m in entityType.MetadataSets)
{
if (m.Id < 1)
{
continue;
}
Db.MetadataSets.Attach(m);
}
}
public ActionResult Delete(int?id)
{
CFEntityType model = null;
if (id.HasValue && id.Value > 0)
{
model = EntityTypeService.GetEntityTypeById(id.Value); //Db.EntityTypes.Where(et => et.Id == id).FirstOrDefault();
if (model != null)
{
EntityTypeService.DeleteEntityType(model);//Db.Entry(model).State = EntityState.Deleted;
Db.SaveChanges(User.Identity);
}
}
return(RedirectToAction("index"));
}
public CFEntityType CreateEntityType(CFEntityType entityType)
{
CFEntityType result = Db.EntityTypes.Add(entityType);
foreach (var m in entityType.MetadataSets)
{
if (m.Id < 1)
{
continue;
}
Db.MetadataSets.Attach(m);
}
return(result);
}
// GET: Manager/EntityTypes/Edit/5
public ActionResult Edit(int?id)
{
CFEntityType model = null;
if (id.HasValue && id.Value > 0)
{
model = EntityTypeService.GetEntityTypeById(id.Value);
}
else
{
model = new CFEntityType();
}
EntityTypeViewModel vm = new EntityTypeViewModel();
vm.UpdateViewModel(model, Db);
return(View(vm));
}
private void CreateEntityTypes()
{
CFMetadataSet metadata = Ms.GetMetadataSets().FirstOrDefault();
for (int i = 0; i < TOTAL_ENTITYTYPES; ++i)
{
CFEntityType et = new CFEntityType();
et.Name = "Entity" + (i + 1);
et.MetadataSets.Add(metadata);
List <eTarget> targets = new List <eTarget>();
if (i % 2 == 0)
{
targets.Add(eTarget.Items);
}
if (i % 5 == 1)
{
targets.Add(eTarget.Collections);
}
et.TargetTypesList = targets;
et.AttributeMappings.Add(new CFEntityTypeAttributeMapping()
{
Name = "Name Mapping",
MetadataSet = metadata,
FieldName = "Name"
});
et.AttributeMappings.Add(new CFEntityTypeAttributeMapping()
{
Name = "Description Mapping",
MetadataSet = metadata,
FieldName = "Description"
});
Db.EntityTypes.Add(et);
}
Db.SaveChanges();
}
public bool UpdateEntityType(CFEntityType entityType)
{
try
{
if (entityType.Id > 0)
{
//modified
Db.Entry(entityType).State = System.Data.Entity.EntityState.Modified;
}
else
{
//add new one
Db.EntityTypes.Add(entityType);
}
return(true);
}
catch (Exception ex)
{
throw ex;
}
}
public CFItem SaveSubmission(Form form, string formSubmissionRef, int itemId, int entityTypeId, int formTemplateId, int collectionId, IDictionary <string, string> metadataAttributeMapping = null)
{
CFItem submissionItem;
if (itemId == 0)
{
submissionItem = CreateEntity <CFItem>(entityTypeId);
// submissionItem.m
Db.Items.Add(submissionItem);
}
else
{
submissionItem = Db.Items.Where(m => m.Id == itemId).FirstOrDefault();
if (submissionItem == null)
{
throw new Exception("Specified item not found");
}
submissionItem.LogChange(submissionItem.Guid, "Updated.");
Db.Entry(submissionItem).State = System.Data.Entity.EntityState.Modified;
}
CFFormSubmission storedFormSubmission = submissionItem.GetFormSubmission(formSubmissionRef);
if (storedFormSubmission == null)
{
//if no stored form is available, we need to clone the template
Form template = Db.FormTemplates.Where(m => m.Id == formTemplateId).FirstOrDefault();
if (template == null)
{
throw new Exception("Form template does not exist.");
}
storedFormSubmission = new CFFormSubmission();
storedFormSubmission.ReplaceFormData(new XElement(template.Data));
submissionItem.AddData(storedFormSubmission);
}
storedFormSubmission.UpdateFormData(form);
//If any attachments have been submitted through the form and they have not yet been included in the
//submission item, then include them and remove them from the main XMLModel table
var attachmentFields = form.Fields.Where(f => f is Attachment).Select(f => f as Attachment);
foreach (var att in attachmentFields)
{
UpdateFiles(att, submissionItem);
}
if (collectionId > 0)
{
CFCollection collection = Db.Collections.Where(c => c.Id == collectionId).FirstOrDefault();
if (collection == null)
{
throw new Exception("Specified collection not found");
}
collection.AppendChild(submissionItem);
}
//MR April 10 2018
//update metadata field's value based on the attribute mapping
//for example if "Name mapping" mapped to the Form's Title field, grab the value of the form title and set it to Metadata Set "Name Mapping Attribute"
EntityTypeService entityTypeService = new EntityTypeService(Db);
CFEntityType entityType = entityTypeService.GetEntityTypeById(entityTypeId);
foreach (KeyValuePair <string, string> map in metadataAttributeMapping)
{
//key: attributeMapping, value Form's Field's Name
string attMapping = map.Key;
string FieldName = map.Value;
FormField formField = storedFormSubmission.FormData.Fields.Where(f => f.Name == FieldName).FirstOrDefault();
var FieldValues = formField.GetValues();
CFEntityTypeAttributeMapping am = entityType.AttributeMappings.Where(a => a.Name == attMapping).FirstOrDefault();
CFMetadataSet ms = null;
if (am != null)
{
ms = entityType.MetadataSets.Where(m => m.Id == am.MetadataSetId).FirstOrDefault();
}
FormField field;
if (ms != null)
{
field = ms.Fields.Where(f => f.Name == am.FieldName).FirstOrDefault();
}
foreach (var fVal in FieldValues)
{
ms.SetFieldValue(am.FieldName, fVal.Value, fVal.LanguageCode);
}
}
//end of MR
submissionItem.Serialize();
return(submissionItem);
}
public void CanCreateSolrDictionary()
{
const string entityTypeName = "Entity type name";
const double numericValue = 42.0;
MockEntity MockEntityChanges = new MockEntity();
List <FormField> formFields = new List <FormField>();
TextValue stringTextValue = new TextValue();
stringTextValue.LanguageCode = "en";
stringTextValue.Value = "Forty two";
TextField textField = new TextField();
textField.Name = "Text";
textField.SetTextValues(new List <TextValue>()
{
stringTextValue
});
formFields.Add(textField);
TextValue numericTextValue = new TextValue();
numericTextValue.LanguageCode = "en";
numericTextValue.Value = numericValue.ToString();
TextField numericField = new TextField();
numericField.Name = "Numeric";
numericField.SetTextValues(new List <TextValue>()
{
numericTextValue
});
formFields.Add(numericField);
// Add two options and select second
OptionsField optionsField = new OptionsField();
optionsField.Name = "Options field";
TextValue nonSelectedValue = new TextValue();
nonSelectedValue.LanguageCode = "en";
nonSelectedValue.Value = "Not selected";
TextValue selectedValue = new TextValue();
selectedValue.LanguageCode = "en";
selectedValue.Value = "Selected";
Option notSelectedOption = new Option();
notSelectedOption.Selected = false;
notSelectedOption.Value.Add(nonSelectedValue);
Option selectedOption = new Option();
selectedOption.Selected = true;
selectedOption.Value.Add(selectedValue);
List <Option> optList = new List <Option>();
optList.Add(notSelectedOption);
optList.Add(selectedOption);
optionsField.Options = optList;
formFields.Add(optionsField);
CFMetadataSet metadataSet = CreateMetadataSet(
mDh,
"name metadataset",
"description metadataset",
formFields);
CFEntityType entityType = CreateEntityType(mDh,
entityTypeName,
"description entity type",
"Items",
metadataSet
);
MockEntity.EntityType = entityType;
MockEntityChanges.EntityType = entityType;
//MockEntityChanges.MetadataSets
MockEntity.MetadataSets = new List <CFMetadataSet>()
{
metadataSet
};
MockEntityChanges.MetadataSets = new List <CFMetadataSet>()
{
metadataSet
};
MockEntityChanges.MetadataSets[0].UpdateValueFields(formFields);
MockEntity.UpdateValues(MockEntityChanges);
// set vales
//MockEntity.MetadataSets[0].UpdateValueFields(test);
Dictionary <string, object> solrDictionary =
MockEntity.ToSolrDictionary();
string metadataSetGuid = metadataSet.MappedGuid.ToString().Replace("-", "_");
string textFieldGuid = textField.MappedGuid.ToString().Replace("-", "_");
string numericFieldGuid = numericField.MappedGuid.ToString().Replace("-", "_");
string optionFieldGuid = optionsField.MappedGuid.ToString().Replace("-", "_");
Dictionary <string, object> expectedResult = new Dictionary <string, object>()
{
{ "id", solrDictionary["id"] },
{ "modeltype_s", MockEntity.GetType().Name },
{ "entitytype_s", entityTypeName },
{ $@"name_{metadataSetGuid}_{textFieldGuid}_txt_en",
textField.Name },
{ $@"name_{metadataSetGuid}_{numericFieldGuid}_txt_en",
numericField.Name },
{ $@"name_{metadataSetGuid}_{optionFieldGuid}_txt_en",
optionsField.Name },
{ $@"value_{metadataSetGuid}_{textFieldGuid}_txts_en",
new List <string>()
{
textField.Values[0].Value
} },
{ $@"value_{metadataSetGuid}_{numericFieldGuid}_txts_en",
new List <string>()
{
numericValue.ToString()
} },
{ $@"value_{metadataSetGuid}_{numericFieldGuid}_ds",
new List <decimal>()
{
(decimal)numericValue
} },
{ $@"value_{metadataSetGuid}_{numericFieldGuid}_is",
new List <int>()
{
(int)numericValue
} },
{ $@"value_{metadataSetGuid}_{optionFieldGuid}_txts_en",
new List <string>()
{
selectedValue.Value
} }
};
foreach (KeyValuePair <string, object> entry in expectedResult)
{
Assert.AreEqual(entry.Value, solrDictionary[entry.Key]);
}
}
public void Import(Ingestion ingestion)
{
#if DEBUG
Console.Error.WriteLine("Starting ingestion of Ingestion object.");
#endif
//create new GUID and new EntityType-Id
Dictionary <string, string> GuidMap = new Dictionary <string, string>();
Dictionary <int, int> IdMap = new Dictionary <int, int>();
foreach (CFMetadataSet ms in ingestion.MetadataSets)
{
string oldId = ms.Guid;
string newGuid = NewGuid();
var meta = ms;
if (ingestion.Overwrite)
{
//use whatever GUID in the file
//check to make sure the GUID in not existing in the Db, if it's replace the one in the database
GuidMap.Add(oldId, oldId); //if overwrite is true use existing GUID
}
else
{
GuidMap.Add(oldId, newGuid);
}
//GuidMap = buildMapGuid(ingestion.Overwrite, oldId);
ms.Guid = GuidMap[oldId];
ms.MappedGuid = GuidMap[oldId];
ms.Serialize();
//meta.Serialize();
if (ingestion.Overwrite)
{
//check if the metadataset with this guid is existed in the database
//if yes, replace the one in th edatabase with this one from the file
CFMetadataSet metadataSet = Db.MetadataSets.Where(m => m.MappedGuid == ms.Guid).FirstOrDefault();
if (metadataSet != null)
{
metadataSet = ms;
Db.Entry(metadataSet).State = System.Data.Entity.EntityState.Modified;
}
else
{
Db.MetadataSets.Add(ms);
}
}
else
{
try
{
Db.MetadataSets.Add(ms);
}catch (ProviderIncompatibleException ex)
{
Console.Error.WriteLine("Current Connection String: " + Db.Database.Connection.ConnectionString);
throw ex;
}
}
}
Db.SaveChanges();
//add entityType
foreach (CFEntityType et in ingestion.EntityTypes)
{
int oldId = et.Id;
//I think below is not necessary since the DeserialiseEntytyType mtehod already grabbing the right metadataset
List <CFMetadataSet> newSets = new List <CFMetadataSet>();
foreach (CFMetadataSet set in et.MetadataSets)
{
string mGuid = set.Guid;
if (GuidMap.ContainsKey(mGuid))
{
mGuid = GuidMap[mGuid];
}
CFMetadataSet dbSet = Db.MetadataSets.Where(s => s.MappedGuid == mGuid).FirstOrDefault();
newSets.Add(dbSet);
}
et.MetadataSets.Clear();
et.MetadataSets = newSets;
foreach (CFEntityTypeAttributeMapping mapping in et.AttributeMappings)
{
string mGuid = mapping.MetadataSet.Guid;
if (GuidMap.ContainsKey(mGuid))
{
mGuid = GuidMap[mGuid];
}
mapping.MetadataSet = Db.MetadataSets.Where(m => m.MappedGuid == mGuid).FirstOrDefault();
}
CFEntityType newEt = null;
if (ingestion.Overwrite)
{
CFEntityType oldEt = Db.EntityTypes.Where(e => e.Name == et.Name).FirstOrDefault();
if (oldEt != null)
{
//modified it --replace with current value
oldEt = et;
Db.Entry(oldEt).State = System.Data.Entity.EntityState.Modified;
}
else
{
newEt = Db.EntityTypes.Add(et);
}
}
else
{
newEt = Db.EntityTypes.Add(et);
}
Db.SaveChanges();
IdMap.Add(oldId, newEt.Id);
}
//add aggregations
GuidMap.Clear();
int completed = 0;
int failed = 0;
IDictionary <Type, Func <IngestionService, CFXmlModel, CFAggregation> > createAggrigationCache = new Dictionary <Type, Func <IngestionService, CFXmlModel, CFAggregation> >();
Func <CFXmlModel, CFAggregation> getNewAggregation = agg =>
{
Type t = agg.GetType();
try
{
return(createAggrigationCache[t](this, agg));
}
catch (KeyNotFoundException ex)
{
MethodInfo method = this.GetType().GetMethod("CreateAggregation");
MethodInfo genMethod = method.MakeGenericMethod(t);
Func <IngestionService, CFXmlModel, CFAggregation> func = (Func <IngestionService, CFXmlModel, CFAggregation>)Delegate.CreateDelegate(typeof(Func <IngestionService, CFXmlModel, CFAggregation>), genMethod);
createAggrigationCache.Add(t, func);
Console.WriteLine("Exception : {0}", ex.Message);
return(func(this, agg));
}
};
ingestion.Aggregations.ForEach((agg) => {
Regex guidRegex = new Regex(@"(guid)=[""']?((?:.(?![""']?\s + (?:\S +)=|[> ""']))+.)[""']?");
string oldId = guidRegex.Match(agg.Content).Groups[2].Value;
string newGuid = NewGuid();
//saving the aggregation object
if (ingestion.Overwrite)
{
//use whatever GUID in the file
//check to make sure the GUID in not existing in the Db, if it's replace the one in the database
GuidMap.Add(oldId, oldId); //if overwrite is true use existing GUID
CFAggregation _aggregation = Db.XmlModels.Where(a => a.MappedGuid == oldId).FirstOrDefault() as CFAggregation;
if (_aggregation != null)
{
_aggregation = (CFAggregation)agg;
Db.Entry(_aggregation).State = System.Data.Entity.EntityState.Modified;
}
else
{
var _agg = getNewAggregation(agg);
Db.Entities.Add(_agg);
}
}
else
{
agg.Guid = newGuid;
agg.MappedGuid = newGuid;
GuidMap.Add(oldId, newGuid);
var _agg = getNewAggregation(agg);
try
{
Db.Entities.Add(_agg);
}catch (Exception ex)
{
#if DEBUG
Console.Error.WriteLine("{0} Error reading aggrigation: {1}", ex.Message, _agg.Name);
#endif
return(false);
}
}
return(true);
}, (successCount, failCount) =>
{
completed += successCount;
failed += failCount;
#if DEBUG
Console.Error.WriteLine("{0} Completed, {1} Failed", completed, failed);
#endif
Db.SaveChanges();
return(true);
});
Db.SaveChanges();
foreach (var rel in ingestion.Relationships)
{
string pGuid = rel.ParentRef;
if (GuidMap.ContainsKey(pGuid))
{
pGuid = GuidMap[pGuid];
}
string cGuid = rel.ChildRef;
if (GuidMap.ContainsKey(cGuid))
{
cGuid = GuidMap[cGuid];
}
rel.ParentRef = pGuid;
rel.ChildRef = cGuid;
if (rel.IsMember)
{
AddMember(rel.ParentRef, rel.ChildRef);
}
if (rel.IsRelated)
{
//save it in Aggregation has related
AddRelatedMember(rel.ParentRef, rel.ChildRef);
}
}
}
public void Import(Ingestion ingestion)
{
//create new GUID and new EntityType-Id
Dictionary <string, string> GuidMap = new Dictionary <string, string>();
Dictionary <int, int> IdMap = new Dictionary <int, int>();
foreach (CFMetadataSet ms in ingestion.MetadataSets)
{
string oldId = ms.Guid;
string newGuid = NewGuid();
var meta = ms;
if (ingestion.Overwrite)
{
//use whatever GUID in the file
//check to make sure the GUID in not existing in the Db, if it's replace the one in the database
GuidMap.Add(oldId, oldId); //if overwrite is true use existing GUID
}
else
{
GuidMap.Add(oldId, newGuid);
}
//GuidMap = buildMapGuid(ingestion.Overwrite, oldId);
ms.Guid = GuidMap[oldId];
ms.MappedGuid = GuidMap[oldId];
ms.Serialize();
//meta.Serialize();
if (ingestion.Overwrite)
{
//check if the metadataset with this guid is existed in the database
//if yes, replace the one in th edatabase with this one from the file
CFMetadataSet metadataSet = Db.MetadataSets.Where(m => m.MappedGuid == ms.Guid).FirstOrDefault();
if (metadataSet != null)
{
metadataSet = ms;
Db.Entry(metadataSet).State = System.Data.Entity.EntityState.Modified;
}
else
{
Db.MetadataSets.Add(ms);
}
}
else
{
Db.MetadataSets.Add(ms);
}
}
Db.SaveChanges();
//add entityType
foreach (CFEntityType et in ingestion.EntityTypes)
{
int oldId = et.Id;
//I think below is not necessary since the DeserialiseEntytyType mtehod already grabbing the right metadataset
List <CFMetadataSet> newSets = new List <CFMetadataSet>();
foreach (CFMetadataSet set in et.MetadataSets)
{
string mGuid = set.Guid;
if (GuidMap.ContainsKey(mGuid))
{
mGuid = GuidMap[mGuid];
}
CFMetadataSet dbSet = Db.MetadataSets.Where(s => s.MappedGuid == mGuid).FirstOrDefault();
newSets.Add(dbSet);
}
et.MetadataSets.Clear();
et.MetadataSets = newSets;
foreach (CFEntityTypeAttributeMapping mapping in et.AttributeMappings)
{
string mGuid = mapping.MetadataSet.Guid;
if (GuidMap.ContainsKey(mGuid))
{
mGuid = GuidMap[mGuid];
}
mapping.MetadataSet = Db.MetadataSets.Where(m => m.MappedGuid == mGuid).FirstOrDefault();
}
CFEntityType newEt = null;
if (ingestion.Overwrite)
{
CFEntityType oldEt = Db.EntityTypes.Where(e => e.Name == et.Name).FirstOrDefault();
if (oldEt != null)
{
//modified it --replace with current value
oldEt = et;
Db.Entry(oldEt).State = System.Data.Entity.EntityState.Modified;
}
else
{
newEt = Db.EntityTypes.Add(et);
}
}
else
{
newEt = Db.EntityTypes.Add(et);
}
Db.SaveChanges();
IdMap.Add(oldId, newEt.Id);
}
//add aggregations
GuidMap.Clear();
foreach (var agg in ingestion.Aggregations)
{
string oldId = agg.Guid;
string newGuid = NewGuid();
if (ingestion.Overwrite)
{
//use whatever GUID in the file
//check to make sure the GUID in not existing in the Db, if it's replace the one in the database
GuidMap.Add(oldId, oldId); //if overwrite is true use existing GUID
}
else
{
agg.Guid = newGuid;
agg.MappedGuid = newGuid;
GuidMap.Add(oldId, newGuid);
}
//saving the aggregation object
if (ingestion.Overwrite)
{
CFAggregation _aggregation = Db.XmlModels.Where(a => a.MappedGuid == newGuid).FirstOrDefault() as CFAggregation;
if (_aggregation != null)
{
_aggregation = (CFAggregation)agg;
Db.Entry(_aggregation).State = System.Data.Entity.EntityState.Modified;
}
else
{
Type t = agg.GetType();
MethodInfo method = this.GetType().GetMethod("CreateAggregation");
MethodInfo genMethod = method.MakeGenericMethod(t);
var _agg = (CFAggregation)genMethod.Invoke(this, new object[] { agg });
Db.Entities.Add(_agg);
}
}
else
{
Type t = agg.GetType();
MethodInfo method = this.GetType().GetMethod("CreateAggregation");
MethodInfo genMethod = method.MakeGenericMethod(t);
var _agg = (CFAggregation)genMethod.Invoke(this, new object[] { agg });
Db.Entities.Add(_agg);
}
}
Db.SaveChanges();
foreach (var rel in ingestion.Relationships)
{
string pGuid = rel.ParentRef;
if (GuidMap.ContainsKey(pGuid))
{
pGuid = GuidMap[pGuid];
}
string cGuid = rel.ChildRef;
if (GuidMap.ContainsKey(cGuid))
{
cGuid = GuidMap[cGuid];
}
rel.ParentRef = pGuid;
rel.ChildRef = cGuid;
if (rel.IsMember)
{
AddMember(rel.ParentRef, rel.ChildRef);
}
if (rel.IsRelated)
{
//save it in Aggregation has related
AddRelatedMember(rel.ParentRef, rel.ChildRef);
}
}
}
public override void UpdateDataModel(object dataModel, CatfishDbContext db)
{
CFEntityType model = dataModel as CFEntityType;
model.Name = Name;
model.Description = Description;
//Mr jan 15 2018
var TargetTypesList = new List <CFEntityType.eTarget>();
for (int i = 0; i < TargetType.Count; ++i)
{
if (TargetType[i])
{
TargetTypesList.Add((CFEntityType.eTarget)i);
}
}
model.TargetTypesList = TargetTypesList;
List <int> dataModelMetadataSetIds = model.MetadataSets.Select(m => m.Id).ToList();
List <int> viewModelMetadataSetIds = AssociatedMetadataSets.Select(m => m.Id).ToList();
//Removing metadata sets that are already associated with the data model but not with the view model
foreach (int id in dataModelMetadataSetIds)
{
if (!viewModelMetadataSetIds.Contains(id))
{
model.MetadataSets.Remove(model.MetadataSets.Where(m => m.Id == id).FirstOrDefault());
}
}
//Adding metadata sets that are in the view model but not in the data model to the data model.
foreach (int id in viewModelMetadataSetIds)
{
if (!dataModelMetadataSetIds.Contains(id))
{
CFMetadataSet ms = db.MetadataSets.Where(s => s.Id == id).FirstOrDefault();
if (ms != null)
{
model.MetadataSets.Add(ms);
}
}
}
// Remvoe all the missing attribute mappings.
model.AttributeMappings.Clear();
foreach (var map in AttributeMappings)
{
CFEntityTypeAttributeMapping attrMapping = new CFEntityTypeAttributeMapping
{
Id = map.Id,
Name = map.Name,
FieldName = map.Field,
MetadataSetId = map.MetadataSetFieldId,
Label = map.Label,
Deletable = map.Deletable
};
if (map.Id > 0)
{
CFEntityTypeAttributeMapping oldAttrMapping = db.EntityTypeAttributeMappings.Find(map.Id);
db.Entry(oldAttrMapping).CurrentValues.SetValues(attrMapping);
attrMapping = oldAttrMapping;
}
model.AttributeMappings.Add(attrMapping);
}
}
public void UpdateViewModel(object dataModel, CatfishDbContext db)
{
CFEntityType model = dataModel as CFEntityType;
Id = model.Id;
Name = model.Name;
if (!string.IsNullOrEmpty(Name))
{
ErrorMessage = "";
}
Description = model.Description;
// TargetType = model.TargetType.ToString();
foreach (var tt in model.TargetTypesList) //MR jan 15 2018
{
TargetType[(int)tt] = true;
}
CFTypeLabelAttribute att = Attribute.GetCustomAttribute(model.GetType(), typeof(CFTypeLabelAttribute)) as CFTypeLabelAttribute;
TypeLabel = att == null?model.GetType().ToString() : att.Name;
//populating the available metadata sets array
MetadataService srv = new MetadataService(db);
var metadataSets = srv.GetMetadataSets();
AvailableMetadataSets.Clear();
AvailableMetadataSets.Add(new MetadataSetListItem(0, ""));
foreach (var ms in metadataSets)
{
if (!string.IsNullOrEmpty(ms.Name))
{
AvailableMetadataSets.Add(new MetadataSetListItem(ms.Id, ms.Name));
List <string> addList = new List <string>();
addList.Add("");
addList = addList.Concat((ms.Fields.Select(f => f.Name).ToList())).ToList();
if (!MetadataSetFields.ContainsKey(ms.Id.ToString()))
{
MetadataSetFields.Add(ms.Id.ToString(), addList);
}
}
}
//populating the associated metadata sets array
AssociatedMetadataSets.Clear();
foreach (var ms in model.MetadataSets)
{
AssociatedMetadataSets.Add(new MetadataSetListItem(ms.Id, ms.Name));
}
AttributeMappings.Clear();
if (model.AttributeMappings.Count > 0)
{
foreach (CFEntityTypeAttributeMapping map in model.AttributeMappings)
{
if (map.Name.Equals("Name Mapping"))// || map.Name.Equals("Description Mapping"))
{
map.Deletable = false;
}
AttributeMappings.Add(new AttributeMapping
{
Id = map.Id,
Name = map.Name,
Field = map.FieldName,
MetadataSetFieldId = map.MetadataSetId,
Label = map.Label,
Deletable = map.Deletable
});
}
}
else
{
AttributeMappings.Add(new AttributeMapping {
Id = 0, Name = "Name Mapping", Deletable = false
});
AttributeMappings.Add(new AttributeMapping {
Id = 0, Name = "Description Mapping", Deletable = true, ErrorMessage = ""
});
}
}
private Ingestion DeserializeEntityTypes(XElement element)
{
foreach (XElement entityElement in element.Elements())
{
CFEntityType entityType = new CFEntityType();
entityType.Id = entityElement.Attribute("id") == null ? 0 : int.Parse(entityElement.Attribute("id").Value);
foreach (XElement child in entityElement.Elements())
{
string name = child.Name.LocalName;
if (name == "name")
{
entityType.Name = child.Value;
}
else if (name == "description")
{
entityType.Description = child.Value;
}
else if (name == "target-type")
{
entityType.TargetTypes = child.Value;
}
else if (name == "metadata-sets")
{
foreach (XElement metadata in child.Elements())
{
if (metadata.Name.LocalName == "metadata-set")
{
//MetadataSet set = MetadataSets.Where(m => m.Guid == metadata.Attribute("ref").Value).FirstOrDefault();
//if (set == null)
//{
CFMetadataSet set = new CFMetadataSet();
set.Guid = metadata.Attribute("ref").Value;
set.Id = -1;
//}
entityType.MetadataSets.Add(set);
foreach (XElement attrElement in metadata.Elements())
{
if (attrElement.Name.LocalName == "attribute-mapping")
{
CFEntityTypeAttributeMapping mapping = new CFEntityTypeAttributeMapping();
mapping.MetadataSet = set;
foreach (XElement attrChild in attrElement.Elements())
{
string attrName = attrChild.Name.LocalName;
if (attrName == "name")
{
mapping.Name = attrChild.Value;
}
else if (attrName == "field-name")
{
mapping.FieldName = attrChild.Value;
}
else if (attrName == "label")
{
//When we implement the new mappings in a later sprint, we will need this field.
}
}
entityType.AttributeMappings.Add(mapping);
}
}
}
}
}
}
EntityTypes.Add(entityType);
}
return(this);
}
