public void Map(ClassMappingBase classMap, Member member)
{
if (!(classMap is ClassMapping))
{
return;
}
var version = new VersionMapping
{
ContainingEntityType = classMap.Type,
};
version.Set(x => x.Name, Layer.Defaults, member.Name);
version.Set(x => x.Type, Layer.Defaults, GetDefaultType(member));
var columnMapping = new ColumnMapping();
columnMapping.Set(x => x.Name, Layer.Defaults, member.Name);
version.AddColumn(Layer.Defaults, columnMapping);
SetDefaultAccess(member, version);
if (IsSqlTimestamp(member))
{
version.Columns.Each(column =>
{
column.Set(x => x.SqlType, Layer.Defaults, "timestamp");
column.Set(x => x.NotNull, Layer.Defaults, true);
});
version.Set(x => x.UnsavedValue, Layer.Defaults, null);
}
((ClassMapping)classMap).Set(x => x.Version, Layer.Defaults, version);
}
public override void Visit(VersionMapping versionMapping)
{
var writer = serviceLocator.GetWriter <VersionMapping>();
var xml = writer.Write(versionMapping);
document.ImportAndAppendChild(xml);
}
public override void ProcessVersion(VersionMapping mapping)
{
var conventions = finder.Find <IVersionConvention>();
Apply <IVersionInspector, IVersionInstance>(conventions,
new VersionInstance(mapping));
}
public override void Visit(VersionMapping versionMapping)
{
var writer = serviceLocator.GetWriter<VersionMapping>();
var xml = writer.Write(versionMapping);
document.ImportAndAppendChild(xml);
}
public void Map(ClassMappingBase classMap, Member property)
{
if (!(classMap is ClassMapping))
{
return;
}
var version = new VersionMapping
{
Name = property.Name,
};
version.SetDefaultValue("Type", GetDefaultType(property));
version.AddDefaultColumn(new ColumnMapping {
Name = property.Name
});
if (IsSqlTimestamp(property))
{
version.Columns.Each(x =>
{
x.SqlType = "timestamp";
x.NotNull = true;
});
version.UnsavedValue = null;
}
((ClassMapping)classMap).Version = version;
}
public void Map(ClassMappingBase classMap, Member member)
{
if (!(classMap is ClassMapping))
{
return;
}
var version = new VersionMapping
{
Name = member.Name,
ContainingEntityType = classMap.Type,
};
version.SetDefaultValue("Type", GetDefaultType(member));
version.AddDefaultColumn(new ColumnMapping {
Name = member.Name
});
if (member.IsProperty && !member.CanWrite)
{
version.Access = cfg.GetAccessStrategyForReadOnlyProperty(member).ToString();
}
if (IsSqlTimestamp(member))
{
version.Columns.Each(x =>
{
x.SqlType = "timestamp";
x.NotNull = true;
});
version.UnsavedValue = null;
}
((ClassMapping)classMap).Version = version;
}
public void ShouldWriteColumns()
{
var mapping = new VersionMapping();
mapping.AddColumn(Layer.Defaults, new ColumnMapping("Column1"));
writer.VerifyXml(mapping)
.Element("column").Exists();
}
public void ShouldWriteColumns()
{
var mapping = new VersionMapping();
mapping.AddColumn(new ColumnMapping {
Name = "Column1"
});
writer.VerifyXml(mapping)
.Element("column").Exists();
}
public DtoVersion GetAllVersionInfo()
{
var versionDto = new DtoVersion();
var dbversions = _uow.VersionRepository.GetById(1);
versionDto.DatabaseVersion = dbversions.DatabaseVersion;
var versionMapping = new VersionMapping().Get();
versionDto.TargetDbVersion = versionMapping[SettingStrings.GlobalVersion];
return(versionDto);
}
public DtoActionResult Update()
{
var result = new DtoActionResult();
var updatesToRun = new List <int>();
var currentDbVersion = new ServiceVersion().Get(1).DatabaseVersion;
var currentAppVersion = SettingStrings.GlobalVersion;
var versionMapping = new VersionMapping().Get();
var targetDbVersion = versionMapping[currentAppVersion];
var trimmedCurrent = currentDbVersion.Remove(currentDbVersion.Length - 1, 1);
var currentInt = Convert.ToInt32(trimmedCurrent.Replace(".", ""));
var trimmedTarget = targetDbVersion.Remove(targetDbVersion.Length - 1, 1);
var targetInt = Convert.ToInt32(trimmedTarget.Replace(".", ""));
if (targetDbVersion != currentDbVersion)
{
foreach (var v in versionMapping)
{
var trimmedValue = v.Value.Remove(v.Value.Length - 1, 1);
var valueInt = Convert.ToInt32(trimmedValue.Replace(".", ""));
if (valueInt > currentInt && valueInt <= targetInt)
{
updatesToRun.Add(valueInt);
}
}
}
var ordered = updatesToRun.OrderBy(x => x).Distinct().ToList();
foreach (var version in ordered)
{
var type = Type.GetType("Toems_Common.DbUpgrades._" + version + ", Toems-Common");
try
{
var instance = Activator.CreateInstance(type) as IDbScript;
_rawSqlServices.ExecuteQuery(instance.Get());
result.Success = true;
}
catch (Exception ex)
{
log.Error("Could Not Update Database To Version " + version);
log.Error(ex.Message);
result.Success = false;
result.ErrorMessage = "Could Not Update Database To Version " + version + "<br>" + ex.Message;
return(result);
}
}
return(result);
}
public VersionDTO GetAllVersionInfo()
{
var versionDto = new VersionDTO();
var dbversions = _uow.CdVersionRepository.GetById(1);
versionDto.FirstRunCompleted = Convert.ToBoolean(_uow.CdVersionRepository.GetById(1).FirstRunCompleted);
versionDto.DatabaseVersion = dbversions.DatabaseVersion;
var versionMapping = new VersionMapping().Get();
versionDto.TargetDbVersion = versionMapping[SettingStrings.Version].ToString();
return(versionDto);
}
void SetDefaultAccess(Member member, VersionMapping mapping)
{
var resolvedAccess = MemberAccessResolver.Resolve(member);
if (resolvedAccess != Access.Property && resolvedAccess != Access.Unset)
{
// if it's a property or unset then we'll just let NH deal with it, otherwise
// set the access to be whatever we determined it might be
mapping.Set(x => x.Access, Layer.Defaults, resolvedAccess.ToString());
}
if (member.IsProperty && !member.CanWrite)
{
mapping.Set(x => x.Access, Layer.Defaults, cfg.GetAccessStrategyForReadOnlyProperty(member).ToString());
}
}
public ActionResultDTO Update()
{
var result = new ActionResultDTO();
var updatesToRun = new List <int>();
var currentDbVersion = Convert.ToInt32(new CdVersionServices().Get(1).DatabaseVersion);
var currentAppVersion = SettingStrings.Version;
var versionMapping = new VersionMapping().Get();
var targetDbVersion = versionMapping[currentAppVersion];
if (targetDbVersion != currentDbVersion)
{
foreach (var v in versionMapping)
{
if (v.Value > currentDbVersion && v.Value <= targetDbVersion)
{
updatesToRun.Add(v.Value);
}
}
}
var ordered = updatesToRun.OrderBy(x => x).Distinct().ToList();
foreach (var version in ordered)
{
var type = Type.GetType("CloneDeploy_Common.DbUpgrades._" + version + ", CloneDeploy-Common");
try
{
var instance = Activator.CreateInstance(type) as IDbScript;
_rawSqlServices.ExecuteQuery(instance.Get());
result.Success = true;
}
catch (Exception ex)
{
log.Error("Could Not Update Database To Version " + version);
log.Error(ex.Message);
result.Success = false;
result.ErrorMessage = "Could Not Update Database To Version " + version + "<br>" + ex.Message;
return(result);
}
}
return(result);
}
VersionMapping IVersionMappingProvider.GetVersionMapping()
{
var mapping = new VersionMapping(attributes.CloneInner());
mapping.ContainingEntityType = entity;
mapping.SetDefaultValue("Name", property.Name);
mapping.SetDefaultValue("Type", property.PropertyType == typeof(DateTime) ? new TypeReference("timestamp") : new TypeReference(property.PropertyType));
mapping.AddDefaultColumn(new ColumnMapping(columnAttributes.CloneInner())
{
Name = property.Name
});
columns.ForEach(column => mapping.AddColumn(new ColumnMapping(columnAttributes.CloneInner())
{
Name = column
}));
return(mapping);
}
VersionMapping IVersionMappingProvider.GetVersionMapping()
{
var mapping = new VersionMapping(attributes.Clone())
{
ContainingEntityType = entity
};
mapping.Set(x => x.Name, Layer.Defaults, member.Name);
mapping.Set(x => x.Type, Layer.Defaults, member.PropertyType == typeof(DateTime) ? new TypeReference("timestamp") : new TypeReference(member.PropertyType));
var defaultColumnMapping = new ColumnMapping(columnAttributes.Clone());
defaultColumnMapping.Set(x => x.Name, Layer.Defaults, member.Name);
mapping.AddColumn(Layer.Defaults, defaultColumnMapping);
columns.ForEach(column =>
{
var columnMapping = new ColumnMapping(columnAttributes.Clone());
columnMapping.Set(x => x.Name, Layer.Defaults, column);
mapping.AddColumn(Layer.UserSupplied, columnMapping);
});
return(mapping);
}
public VersionInspector(VersionMapping mapping)
: base(mapping.Columns)
{
this.mapping = mapping;
propertyMappings.Map(x => x.Nullable, "NotNull");
}
public override void Visit(VersionMapping versionMapping)
{
versionMapping.AcceptVisitor(this);
}
public virtual void ProcessVersion(VersionMapping mapping)
{
}
public virtual void Visit(VersionMapping versionMapping)
{
}
public void CreateDsl()
{
mapping = new VersionMapping();
inspector = new VersionInspector(mapping);
}
public VersionInstance(VersionMapping mapping)
: base(mapping)
{
this.mapping = mapping;
}
