private static Tuple <AccessLevel, AbstractEnum, StaticEnum, VirtualEnum> EmitModifiers(MethodBase method)
{
AccessLevel accessModifier = Model.AccessLevel.Private;
if (method.IsPublic)
{
accessModifier = Model.AccessLevel.Public;
}
else if (method.IsFamily)
{
accessModifier = Model.AccessLevel.Protected;
}
else if (method.IsFamilyAndAssembly)
{
accessModifier = Model.AccessLevel.Internal;
}
AbstractEnum abstractModifier = Model.AbstractEnum.NotAbstract;
if (method.IsAbstract)
{
abstractModifier = Model.AbstractEnum.Abstract;
}
StaticEnum staticModifier = Model.StaticEnum.NonStatic;
if (method.IsStatic)
{
staticModifier = Model.StaticEnum.Static;
}
VirtualEnum virtualModifier = Model.VirtualEnum.NonVirtual;
return(new Tuple <AccessLevel, AbstractEnum, StaticEnum, VirtualEnum>(accessModifier, abstractModifier, staticModifier, virtualModifier));
}
public FieldMetadata(FieldBase fieldMetadata)
{
this.Name = fieldMetadata.Name;
this.Type = TypeMetadata.GetOrAdd(fieldMetadata.Type);
this.AccessLevel = fieldMetadata.AccessLevel.ToLogicEnum();
this.StaticEnum = fieldMetadata.StaticEnum.ToLogicEnum();
}
public static string GetFile(StaticEnum.FileType typeFile, string name)
{
var path = string.Empty;
switch (typeFile)
{
case StaticEnum.FileType.Image:
path = ConfigurationManager.AppSettings["UploadImage"];
break;
case StaticEnum.FileType.ImageThumb:
path = ConfigurationManager.AppSettings["UploadImageThumb"];
break;
case StaticEnum.FileType.Document:
path = ConfigurationManager.AppSettings["UploadDocument"];
break;
case StaticEnum.FileType.Multimedia:
path = ConfigurationManager.AppSettings["UploadMultimedia"];
break;
case StaticEnum.FileType.File:
path = ConfigurationManager.AppSettings["UploadFile"];
break;
}
return path + name;
}
public DatabaseField(FieldBase fieldBase)
{
Name = fieldBase.Name;
Type = DatabaseType.GetOrAdd(fieldBase.Type);
AccessLevel = fieldBase.AccessLevel;
StaticEnum = fieldBase.StaticEnum;
}
public TupleFour(AccessLevel accessLevel, AbstractEnum abstractEnum, StaticEnum staticEnum, VirtualEnum virtualEnum)
{
this.accessLevel = accessLevel;
this.abstractEnum = abstractEnum;
this.staticEnum = staticEnum;
this.virtualEnum = virtualEnum;
}
private void EmitModifiers(FieldInfo field)
{
AccessLevel = field.IsPublic ? AccessLevel.IsPublic :
field.IsFamily ? AccessLevel.IsProtected :
field.IsAssembly ? AccessLevel.Internal : AccessLevel.IsPrivate;
StaticEnum = field.IsStatic ? StaticEnum.Static : StaticEnum.NotStatic;
}
internal static string Stringify(this StaticEnum staticEnum)
{
if (staticEnum == StaticEnum.Static)
{
return("Static ");
}
return("");
}
public static StaticEnumBaseDTO ToBaseDTO(this StaticEnum enumType)
{
switch (enumType)
{
case StaticEnum.NotStatic:
return(StaticEnumBaseDTO.NotStatic);
case StaticEnum.Static:
return(StaticEnumBaseDTO.Static);
}
throw new Exception();
}
public static Tuple <AccessLevel, AbstractEnum, StaticEnum, VirtualEnum> MapToObject(this Tuple <AccessLevelBaseDTO, AbstractEnumBaseDTO, StaticEnumBaseDTO, VirtualEnumBaseDTO> tuple)
{
if (tuple == null)
{
return(null);
}
AccessLevel accessLevelBase = tuple.Item1.MapToObject();
AbstractEnum abstractEnumBase = tuple.Item2.MapToObject();
StaticEnum staticEnumBase = tuple.Item3.MapToObject();
VirtualEnum virtualEnumBase = tuple.Item4.MapToObject();
return(new Tuple <AccessLevel, AbstractEnum, StaticEnum, VirtualEnum>(accessLevelBase, abstractEnumBase, staticEnumBase, virtualEnumBase));
}
internal static Enums.StaticEnum ToLogicEnum(this StaticEnum baseEnum)
{
switch (baseEnum)
{
case StaticEnum.Static:
return(Enums.StaticEnum.Static);
case StaticEnum.NotStatic:
return(Enums.StaticEnum.NotStatic);
default:
throw new Exception();
}
}
private void InsertRedundantData(DbAssemblyMetadata loadedRoot)
{
foreach (DbNamespaceMetadata _namespace in loadedRoot.EFNamespaces)
{
foreach (DbTypeMetadata type in _namespace.EFTypes)
{
type.NamespaceName = _namespace.Name;
AbstractEnum isAbstract = AbstractEnum.NotAbstract;
if (type.IsAbstract)
{
isAbstract = AbstractEnum.Abstract;
}
SealedEnum isSealed = SealedEnum.NotSealed;
if (type.IsSealed)
{
isSealed = SealedEnum.Sealed;
}
type.Modifiers = new Tuple <AccessLevelEnum, SealedEnum, AbstractEnum>(
type.AccessLevel, isSealed, isAbstract);
foreach (DbMethodMetadata method in type.EFMethodsAndConstructors)
{
isAbstract = AbstractEnum.NotAbstract;
if (method.IsAbstract)
{
isAbstract = AbstractEnum.Abstract;
}
StaticEnum isStatic = StaticEnum.NotStatic;
if (method.IsStatic)
{
isStatic = StaticEnum.Static;
}
VirtualEnum isVirtual = VirtualEnum.NotVirtual;
if (method.IsVirtual)
{
isVirtual = VirtualEnum.Virtual;
}
method.Modifiers = new Tuple <AccessLevelEnum, AbstractEnum, StaticEnum, VirtualEnum>(
method.AccessLevel, isAbstract, isStatic, isVirtual);
}
}
}
}
private static MethodModifiers EmitModifiers(MethodBase method)
{
AccessLevel _access = AccessLevel.Private;
if (method.IsPublic)
{
_access = AccessLevel.Public;
}
else if (method.IsFamily)
{
_access = AccessLevel.Protected;
}
else if (method.IsFamilyAndAssembly)
{
_access = AccessLevel.ProtectedInternal;
}
AbstractEnum _abstract = AbstractEnum.NotAbstract;
if (method.IsAbstract)
{
_abstract = AbstractEnum.Abstract;
}
StaticEnum _static = StaticEnum.NotStatic;
if (method.IsStatic)
{
_static = StaticEnum.Static;
}
VirtualEnum _virtual = VirtualEnum.NotVirtual;
if (method.IsVirtual)
{
_virtual = VirtualEnum.Virtual;
}
return(new MethodModifiers()
{
AbstractEnum = _abstract,
StaticEnum = _static,
VirtualEnum = _virtual,
AccessLevel = _access
});
}
static TypeModifiers EmitModifiers(Type type)
{
AccessLevel _access = AccessLevel.Private;
if (type.IsPublic)
{
_access = AccessLevel.Public;
}
else if (type.IsNestedPublic)
{
_access = AccessLevel.Public;
}
else if (type.IsNestedFamily)
{
_access = AccessLevel.Protected;
}
else if (type.IsNestedFamANDAssem)
{
_access = AccessLevel.ProtectedInternal;
}
SealedEnum _sealed = SealedEnum.NotSealed;
if (type.IsSealed)
{
_sealed = SealedEnum.Sealed;
}
AbstractEnum _abstract = AbstractEnum.NotAbstract;
StaticEnum _static = StaticEnum.NotStatic;
if (type.IsAbstract)
{
_abstract = AbstractEnum.Abstract;
_static = StaticEnum.Static;
}
return(new TypeModifiers()
{
AbstractEnum = _abstract,
StaticEnum = _static,
SealedEnum = _sealed,
AccessLevel = _access
});
}
private static MethodModifiers EmitModifiers(MethodBase method)
{
AccessLevel access = method.IsPublic ? AccessLevel.Public :
method.IsFamily ? AccessLevel.Protected :
method.IsAssembly ? AccessLevel.Internal : AccessLevel.Private;
AbstractEnum _abstract = method.IsAbstract ? AbstractEnum.Abstract : AbstractEnum.NotAbstract;
StaticEnum _static = method.IsStatic ? StaticEnum.Static : StaticEnum.NotStatic;
VirtualEnum _virtual = method.IsVirtual ? VirtualEnum.Virtual : VirtualEnum.NotVirtual;
return(new MethodModifiers()
{
AbstractEnum = _abstract,
StaticEnum = _static,
VirtualEnum = _virtual,
AccessLevel = access
});
}
private Tuple <AccessLevel, AbstractEnum, StaticEnum, VirtualEnum> EmitModifiers(MethodBase method)
{
AccessLevel access = AccessLevel.IsPrivate;
if (method.IsPublic)
{
access = AccessLevel.IsPublic;
}
else if (method.IsFamily)
{
access = AccessLevel.IsProtected;
}
else if (method.IsFamilyAndAssembly)
{
access = AccessLevel.IsProtectedInternal;
}
AbstractEnum isAbstract = AbstractEnum.NotAbstract;
if (method.IsAbstract)
{
isAbstract = AbstractEnum.Abstract;
}
StaticEnum isStatic = StaticEnum.NotStatic;
if (method.IsStatic)
{
isStatic = StaticEnum.Static;
}
VirtualEnum isVirtual = VirtualEnum.NotVirtual;
if (method.IsVirtual)
{
isVirtual = VirtualEnum.Virtual;
}
return(new Tuple <AccessLevel, AbstractEnum, StaticEnum, VirtualEnum>(access, isAbstract, isStatic, isVirtual));
}
private Tuple <AccessLevel, AbstractEnum, StaticEnum, VirtualEnum> EmitModifiers(MethodBase method)
{
AccessLevel _access = AccessLevel.Private;
if (method.IsPublic)
{
_access = AccessLevel.Public;
}
else if (method.IsFamily)
{
_access = AccessLevel.Protected;
}
else if (method.IsFamilyAndAssembly)
{
_access = AccessLevel.Internal;
}
AbstractEnum _abstract = AbstractEnum.NotAbstract;
if (method.IsAbstract)
{
_abstract = AbstractEnum.Abstract;
}
else if (method.IsFinal)
{
_abstract = AbstractEnum.Sealed;
}
StaticEnum _static = StaticEnum.NotStatic;
if (method.IsStatic)
{
_static = StaticEnum.Static;
}
VirtualEnum _virtual = VirtualEnum.NotVirtual;
if (method.IsVirtual)
{
_virtual = VirtualEnum.Virtual;
}
return(new Tuple <AccessLevel, AbstractEnum, StaticEnum, VirtualEnum>(_access, _abstract, _static, _virtual));
}
public static void MoveFile(StaticEnum.FileType typeFile, string name)
{
var path = string.Empty;
var sourceFile = HttpContext.Current.Server.MapPath(ConfigWeb.TempPath + name);
var thumbImage = HttpContext.Current.Server.MapPath(ConfigWeb.ImageThumpPath + name);
switch (typeFile)
{
case StaticEnum.FileType.Image:
path = ConfigurationManager.AppSettings["UploadImage"];
break;
case StaticEnum.FileType.Document:
path = ConfigurationManager.AppSettings["UploadDocument"];
break;
case StaticEnum.FileType.Multimedia:
path = ConfigurationManager.AppSettings["UploadMultimedia"];
break;
case StaticEnum.FileType.File:
path = ConfigurationManager.AppSettings["UploadFile"];
break;
}
var fileSave = HttpContext.Current.Server.MapPath(path + name);
if (File.Exists(sourceFile))
{
File.Move(sourceFile, fileSave);
}
if (typeFile == StaticEnum.FileType.Image)
{
ImageResizer.ImageBuilder.Current.Build(fileSave, thumbImage, new ImageResizer.ResizeSettings()
{
MaxWidth = Convert.ToInt32(ConfigurationManager.AppSettings["ThumbWidth"]),
MaxHeight = Convert.ToInt32(ConfigurationManager.AppSettings["ThumbHeight"])
});
}
}
private static TypeModifiers EmitModifiers(Type type)
{
AccessLevel _access = type.IsPublic || type.IsNestedPublic ? AccessLevel.Public :
type.IsNestedFamily ? AccessLevel.Protected :
type.IsNestedPrivate ? AccessLevel.Private :
AccessLevel.Internal;
StaticEnum _static = type.IsSealed && type.IsAbstract ? StaticEnum.Static : StaticEnum.NotStatic;
SealedEnum _sealed = SealedEnum.NotSealed;
AbstractEnum _abstract = AbstractEnum.NotAbstract;
if (_static == StaticEnum.NotStatic)
{
_sealed = type.IsSealed ? SealedEnum.Sealed : SealedEnum.NotSealed;
_abstract = type.IsAbstract ? AbstractEnum.Abstract : AbstractEnum.NotAbstract;
}
return(new TypeModifiers()
{
AbstractEnum = _abstract,
AccessLevel = _access,
SealedEnum = _sealed,
StaticEnum = _static
});
}
public static string StaticToString(StaticEnum staticEnum)
{
return(staticEnum == StaticEnum.Static ? "static" : "");
}
public TupleTwo(AccessLevel accessLevel, StaticEnum staticEnum)
{
this.accessLevel = accessLevel;
this.staticEnum = staticEnum;
}
