public void PreserveNullIDsTest()
{
Guid testId = Guid.NewGuid();
GuidMap map = new GuidMap();
Assert.AreEqual(null, map.MapId(null));
}
public void EnsureIDRelationshipTest()
{
Guid testId = Guid.NewGuid();
GuidMap map = new GuidMap();
Assert.AreEqual(map.MapId(testId), map.MapId(testId));
Assert.AreNotEqual(map.MapId(testId), map.MapId(Guid.NewGuid()));
}
public Guid MapujGuid(Guid zrodlo, string tabela)
{
GuidMap guidMap = ContextManager.WebContext.GuidMaps.Where(m => m.Zrodlo == zrodlo && m.Tabela == tabela).FirstOrDefault();
if (guidMap != null)
{
return((Guid)guidMap.Cel);
}
return(zrodlo);
}
Nullable <Guid> GetParentId(string child)
{
string strParent = this.GetStringParent(child);
if (!GuidMap.ContainsKey(strParent))
{
Guid newGuid = Guid.NewGuid();
GuidMap.Add(strParent, newGuid);
return(newGuid);
}
Nullable <Guid> nullGuid = null;
return((!strParent.Equals("ROOT")) ? GuidMap[strParent] : nullGuid);
}
private void UpdateProjectReferences(Project project, IList <MksProjectFile> mksProjectFiles, ProjectItem[] sysRefs)
{
var projectGuidMap = new GuidMap();
foreach (var mksProjectFile in mksProjectFiles)
{
var originalNameSpace = mksProjectFile.NameSpace.Replace(nameSpacePrefix, originalNameSpacePrefix);
var projectRefs = mksProjectFile.ProjectItems
.SelectMany(c => c.References)
.Where(d => d.StartsWith("MKS") && d.StartsWith(originalNameSpace) == false)
.Distinct();
var projectNames = projectRefs
.Select(c => c.Remove(0, 4).Split('.'))
.Select(c => c.Take(2).ConcatToString(""));
var ItemGroup = new XElement("ItemGroup");
foreach (var projectRef in projectNames)
{
var listOfProjects = new List <XElement>();
if (projectGuidMap.ProjectGuidMap.ContainsKey(projectRef))
{
var guid = projectGuidMap.ProjectGuidMap[projectRef];
var foo = mksProjectFiles.FirstOrDefault(c => c.AssemblyName == projectRef);
var IncludePath = mksProjectFile.AbsoluteTargetUri.MakeRelativeUri(foo.AbsoluteTargetUri).ToString().Replace('/', '\\');
var projectElement = new XElement(
new XElement("ProjectReference"
, new XAttribute("Include", IncludePath)
, new XElement("Project", guid)
, new XElement("Name", projectRef)
));
listOfProjects.Add(projectElement);
}
if (listOfProjects.Count > 0)
{
foreach (var element in listOfProjects)
{
ItemGroup.Add(element);
}
}
}
mksProjectFile.XML = mksProjectFile.XML.Replace(@" <BeginInsertion />",
@" <BeginInsertion />" + "\r\n" + ItemGroup.ToString());
}
}
private void UpdateSystemReferences(Project project, List <MksProjectFile> mksProjectFiles, ProjectItem[] allReferences)
{
var projectGuidMap = new GuidMap();
var projectRefsWithoutHint = project.Items.Where(c =>
c.ItemType == "Reference" &&
c.DirectMetadata.Any(d => d.Name == "HintPath") == false).ToArray();
foreach (var mksProject in mksProjectFiles)
{
var itemGroup = new XElement("ItemGroup");
foreach (var sysRef in projectRefsWithoutHint)
{
itemGroup.Add(new XElement("Reference"
, new XAttribute("Include", sysRef.EvaluatedInclude)
));
}
mksProject.XML = mksProject.XML.Replace(@" <BeginInsertion />",
@" <BeginInsertion />" + "\r\n" + itemGroup.ToString());
}
}
void InitRoot()
{
GuidMap.Add("ROOT", Guid.NewGuid());
}
/// <summary>
/// Creates a new map entry for the oldGuid. This generates a new Guid and
/// stores a reference between the two.
/// </summary>
/// <param name="oldGuid">The original Guid value to be mapped from.</param>
/// <returns>A new Guid value that should be used in place of oldGuid.</returns>
protected Guid MapNewGuid(Guid oldGuid)
{
GuidMap.Add(oldGuid, Guid.NewGuid());
return(GuidMap[oldGuid]);
}
/// <summary>
/// Creates a new entity in the database from the encoded information. The entity
/// is saved before being returned.
/// </summary>
/// <param name="encodedEntity">The encoded entity information to create the new entity from.</param>
/// <returns>A reference to the new entity.</returns>
protected IEntity CreateNewEntity(EncodedEntity encodedEntity)
{
Type entityType = Reflection.FindType(typeof(IEntity), encodedEntity.EntityType);
var service = Reflection.GetServiceForEntityType(entityType, RockContext);
if (service != null)
{
var addMethod = service.GetType().GetMethod("Add", new Type[] { entityType });
if (addMethod != null)
{
IEntity entity = ( IEntity )Activator.CreateInstance(entityType);
RestoreEntityProperties(entity, encodedEntity);
entity.Guid = FindMappedGuid(encodedEntity.Guid);
//
// Do custom pre-save processing.
//
foreach (var processor in FindEntityProcessors(entityType))
{
processor.ProcessImportedEntity(entity, encodedEntity, encodedEntity.GetTransformData(processor.Identifier.ToString()), this);
}
//
// Special handling of AttributeQualifier because Guids may not be the same
// across installations and the AttributeId+Key columns make up a unique key.
//
if (encodedEntity.EntityType == "Rock.Model.AttributeQualifier")
{
var reference = encodedEntity.References.Where(r => r.Property == "AttributeId").First();
var attribute = GetExistingEntity("Rock.Model.Attribute", FindMappedGuid(new Guid(( string )reference.Data)));
string key = ( string )encodedEntity.Properties["Key"];
var existingEntity = new AttributeQualifierService(RockContext)
.GetByAttributeId(attribute.Id)
.Where(a => a.Key == key)
.FirstOrDefault();
if (existingEntity != null)
{
if (entity.Guid != encodedEntity.Guid)
{
throw new Exception("AttributeQualifier marked for new Guid but conflicting value already exists.");
}
GuidMap.AddOrReplace(encodedEntity.Guid, existingEntity.Guid);
return(existingEntity);
}
}
//
// Special handling of Attribute's. The guid's might be different but if the entity type,
// entity qualifiers and key are the same, assume it's the same.
//
else if (encodedEntity.EntityType == "Rock.Model.Attribute")
{
var attribute = (Rock.Model.Attribute)entity;
var existingEntity = new AttributeService(RockContext)
.GetByEntityTypeId(attribute.EntityTypeId)
.Where(a => a.EntityTypeQualifierColumn == attribute.EntityTypeQualifierColumn && a.EntityTypeQualifierValue == attribute.EntityTypeQualifierValue && a.Key == attribute.Key)
.FirstOrDefault();
if (existingEntity != null)
{
if (entity.Guid != encodedEntity.Guid)
{
throw new Exception("Attribute marked for new Guid but conflicting value already exists.");
}
GuidMap.AddOrReplace(encodedEntity.Guid, existingEntity.Guid);
return(existingEntity);
}
}
//
// Special handling of AttributeValue's. The guid's might be different but if the attribute Id
// and entity Id are the same, assume it's the same.
//
else if (encodedEntity.EntityType == "Rock.Model.AttributeValue")
{
var attributeReference = encodedEntity.References.Where(r => r.Property == "AttributeId").First();
var attribute = GetExistingEntity("Rock.Model.Attribute", FindMappedGuid(new Guid(( string )attributeReference.Data)));
var entityReference = encodedEntity.References.Where(r => r.Property == "EntityId").First();
var entityRef = GetExistingEntity(entityReference.EntityType, FindMappedGuid(new Guid(( string )entityReference.Data)));
var existingEntity = new AttributeValueService(RockContext)
.Queryable().Where(a => a.AttributeId == attribute.Id && a.EntityId == entityRef.Id)
.FirstOrDefault();
if (existingEntity != null)
{
if (entity.Guid != encodedEntity.Guid)
{
throw new Exception("AttributeValue marked for new Guid but conflicting value already exists.");
}
GuidMap.AddOrReplace(encodedEntity.Guid, existingEntity.Guid);
return(existingEntity);
}
}
addMethod.Invoke(service, new object[] { entity });
RockContext.SaveChanges(true);
return(entity);
}
}
throw new Exception(string.Format("Failed to create new database entity for {0}_{1}", encodedEntity.EntityType, encodedEntity.Guid));
}
/// <summary>
/// Finds and returns a Guid from the mapping dictionary. If no mapping
/// exists then the original Guid is returned.
/// </summary>
/// <param name="oldGuid">The original Guid value to map from.</param>
/// <returns>The Guid value that should be used, may be the same as oldGuid.</returns>
public Guid FindMappedGuid(Guid oldGuid)
{
return(GuidMap.ContainsKey(oldGuid) ? GuidMap[oldGuid] : oldGuid);
}
