/// <summary> `BuildUsingDirection` builds a new `Dictionary` from an enumeration of directions. </summary>
/// <typeparam name="V"> The type of value the constructed dictionary is filled with. </typeparam>
/// <param name="constructor"> The `ConstructionFunction` used in building the new dictionary. </param>
public static Dictionary <Direction, V> BuildUsingDirection <V>(ConstructorFunction <V> constructor)
{
var dictionary = new Dictionary <Direction, V>();
var keys = Enum.GetValues(typeof(Direction));
foreach (Direction key in keys)
{
V value = constructor(key);
dictionary.Add(key, value);
}
return(dictionary);
}
internal static ConstructorFunction GetConstructor(Type type, BuiltinFunction realTarget, params MethodBase[] mems)
{
ConstructorFunction res = null;
if (mems.Length != 0)
{
ReflectionCache.MethodBaseCache cache = new ReflectionCache.MethodBaseCache("__new__", mems);
lock (_ctors) {
if (!_ctors.TryGetValue(cache, out res))
{
_ctors[cache] = res = new ConstructorFunction(realTarget, mems);
}
}
}
return(res);
}
public ConstructorOverloadMapper(ConstructorFunction builtinFunction, object instance)
: base(builtinFunction, instance)
{
}
public DBFile(string name, string module)
{
TableList = new List <Table>();
using (var sr = new StreamReader(name))
{
var str = sr.ReadToEnd();
foreach (var item in str.GetSlices("/* Create", "/* Create"))
{
if (item.Contains("/* Create Tables */"))
{
GetTable(item);
}
else if (item.Contains("/* Create Primary Keys, Indexes, Uniques, Checks */"))
{
foreach (var constraint in item.GetSlices("ALTER TABLE", $";{NewLine}"))
{
GetPrimaryKeyAndIndex(constraint);
}
}
else if (item.Contains("/* Create Foreign Key Constraints */"))
{
foreach (var constraint in item.GetSlices("ALTER TABLE", $";{NewLine}"))
{
GetForeignKey(constraint);
}
}
else if (item.Contains("/* Create Table Comments, Sequences for Autonumber Columns */"))
{
foreach (var sequence in item.GetSlices("CREATE SEQUENCE", ";"))
{
GetSequence(sequence);
}
foreach (var constraint in item.GetSlices("COMMENT ON", $";{NewLine}"))
{
if (constraint.Trim().StartsWith("COMMENT ON TABLE"))
{
GetTableComment(constraint);
}
else if (constraint.Trim().StartsWith("COMMENT ON COLUMN"))
{
GetColumnComment(constraint);
}
}
}
}
}
EntityConstraintDic = new Dictionary <string, EntityConstraintsClass>();
EntityDic = new Dictionary <string, EntityClass>();
foreach (var table in TableList)
{
table.Schema = "KOVAN_" + module.ToUpperEn();
var moduleName = module.ToLowerEn();
var ec = new EntityConstraintsClass(table, "workshop");
EntityConstraintDic.Add(ec.Name, ec);
var entity = new EntityClass(ec, "workshop");
EntityDic.Add(entity.Name, entity);
}
foreach (var table in TableList)
{
table.Columns.Any(x => x.Constraints.Count > 0);
foreach (var col in table.Columns)
{
if (col.Constraints.Any(x => x is ForeignKey))
{
var entityClass = EntityDic.Values.First(x => x.EntityConstraints.Table.Name == col.Table.Name);
var fkEntityClass = EntityDic.Values.First(x => x.EntityConstraints.Table.Name == (col.Constraints.First(y => y is ForeignKey) as ForeignKey).ReferenceColumn.Table.Name);
if (entityClass.Name == fkEntityClass.Name)
{
continue;
}
var cm = entityClass.ClassMembers.ClassMembers.First(x => x.Name == col.Name.ToCamelCase());
var entityClassMember = new ClassMember(fkEntityClass.Name.Replace("Entity", "").ToLowerFirstCharacter(), fkEntityClass, null, Models.DataModels.Enum.AccessModifier.Private);
entityClass.ClassMembers.Replace(col.Name.ToCamelCase(), entityClassMember);
var listClass = Models.DataModels.Predefined.PredefinedClasses.JavaList;
listClass.GenericList.Add(entityClass);
var fkEntityClassMember = new ClassMember(entityClass.Name.Replace("Entity", "") + "List", listClass, null, Models.DataModels.Enum.AccessModifier.Private);
if (col.Constraints.Any(x => x is Unique) && (col.Constraints.FirstOrDefault(x => x is Unique) as Unique).Columns.Count > 1)
{
fkEntityClass.ClassMembers.Add(fkEntityClassMember);
fkEntityClassMember.Annotations.Add(Models.DataModels.Predefined.PredefinedAnnotations.OneToMany()
.SetParameter("cascade", new ReferenceValue("CascadeType.ALL"))
.SetParameter("mappedBy", entityClassMember.Name));
entityClassMember.Annotations.Add(Models.DataModels.Predefined.PredefinedAnnotations.ManyToOne());
entityClassMember.Annotations.Add(Models.DataModels.Predefined.PredefinedAnnotations.JoinColumn()
.SetParameter("referencedColumnName", fkEntityClass.EntityConstraints.GetStaticMemberByValue((col.Constraints.FirstOrDefault(x => x is ForeignKey) as ForeignKey).Column.Name))
.SetParameter("name", KoGen.Models.DataModels.ReferenceValue.FromStaticMemberByValue(entityClass.EntityConstraints, col.Name))
.SetParameter("foreignKey", Models.DataModels.Predefined.PredefinedAnnotations.ForeignKey()
.SetParameter("name", (col.Constraints.FirstOrDefault(x => x is ForeignKey) as ForeignKey).Name)));
}
else
{
entityClassMember.Annotations.Add(Models.DataModels.Predefined.PredefinedAnnotations.OneToOne());
}
}
}
}
ModelDic = new Dictionary <string, ModelClass>();
foreach (var entityClass in EntityDic.Values)
{
var m = new ModelClass(entityClass, "workshop");
ModelDic.Add(m.Name, m);
}
foreach (var modelClass in ModelDic.Values)
{
foreach (var classMember in modelClass.ClassMembers.ClassMembers)
{
var mClass = ModelDic.Values.FirstOrDefault(x => x.EntityClass.Name == classMember.Type.Name || (classMember.Type == Models.DataModels.Predefined.PredefinedClasses.JavaList && x.EntityClass.Name == classMember.Type.GenericList.First().Name));
if (mClass != null)
{
modelClass.ClassMembers.ChangeType(classMember.Name, mClass);
}
}
}
ConverterDic = new Dictionary <string, ConverterClass>();
foreach (var modelClass in ModelDic.Values)
{
var m = new ConverterClass(modelClass, "workshop");
ConverterDic.Add(m.Name, m);
}
foreach (var converterClass in ConverterDic.Values)
{
foreach (var expression in converterClass.Functions.First(x => x.Name == "doConvertToEntity").Expressions.Where(x => x is SetterAssignExpression).Select(x => x as SetterAssignExpression))
{
if (expression.DestinationClassMember.Type != expression.SourceClassMember.Type)
{
var converter = ConverterDic.Values.FirstOrDefault(x => x.ModelClass != converterClass.ModelClass && x.ModelClass == expression.SourceClassMember.Type);
if (converter != null)
{
if (!converterClass.ClassMembers.ClassMembers.Any(x => x.Type == converter))
{
converterClass.ClassMembers.Add(new ClassMember(converter.Name.ToLowerFirstCharacter(), converter, null, Models.DataModels.Enum.AccessModifier.Private, Models.DataModels.Enum.NonAccessModifier.Transient), false);
}
}
}
}
if (converterClass.ClassMembers.ClassMembers.Count > 0)
{
var ctor = new ConstructorFunction(converterClass);
ctor.Annotations.Add(Models.DataModels.Predefined.PredefinedAnnotations.Autowired());
converterClass.Functions.Insert(0, ctor);
}
}
}
