public ActionResult CreateNew()
{
var model = new TypeCategory();
model.Status = true;
return(View(model));
}
public async Task <IActionResult> PutTypeCategory([FromRoute] int id, [FromBody] TypeCategory typeCategory)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != typeCategory.Id_type)
{
return(BadRequest());
}
_context.Entry(typeCategory).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TypeCategoryExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
private object ProcessEnumValue()
{
object val = null;
var useAlternateXml = Cache.GetAttribute <TypeLookupAttribute>()?.Class == typeof(XmlEnumAlternateName);
if (useAlternateXml)
{
val = ParseEnumValue <XmlEnumAlternateName>();
}
else
{
val = ParseEnumValue <XmlEnumAttribute>();
}
if (val == null)
{
throw GetEnumArgumentException();
}
else
{
Type = TypeCategory.Enum;
}
return(val);
}
public void InsertTypeDigest(TypeDigest type)
{
ResetTypeCache(type);
if (type.TypeCategoryId == GetRootCategoryTypeDigest().Match(() => - 1, t => t.Id))
{
Connect(
ctx => {
ctx.TypeDigests.Add(type);
ctx.SaveChanges();
TypeCategory newCategory = new TypeCategory()
{
Id = type.Id,
TypeTableId = type.TypeTableId
};
ctx.TypeCategories.Add(newCategory);
ctx.SaveChanges();
return(Unit());
}
);
}
else
{
Connect(
ctx => {
ctx.TypeDigests.Add(type);
ctx.SaveChanges();
return(Unit());
}
);
}
}
public static string GetTypeCategoryDisplayString(TypeCategory type)
{
if (type == TypeCategory.StaticClass)
{
return "static class";
}
else if (type == TypeCategory.AbstractClass)
{
return "abstract class";
}
else if (type == TypeCategory.Class)
{
return "class";
}
else if (type == TypeCategory.Enum)
{
return "enum";
}
else if (type == TypeCategory.Interface)
{
return "interface";
}
else if (type == TypeCategory.Struct)
{
return "struct";
}
else
{
return "";
}
}
private object ParseBoolValue()
{
object val = null;
//If ValueType is bool, we must be serialize mode as in DeserializeMode we would have shortcut out of ParseValue
//immediately due to PropertyType and ValueType both being bool
if (ValueType == typeof(bool))
{
Type = TypeCategory.Boolean;
val = Convert.ToInt32((bool)OriginalValue);
}
else
{
bool boolVal;
//OriginalValue is implicitly not null because if it were ProcessNonNullable would have escaped
//to ValueConversionWithNullCheck
if (TryParseBool(OriginalValue.ToString(), out boolVal))
{
Type = TypeCategory.Boolean;
if (Mode == SerializationMode.Deserialize)
{
val = boolVal;
}
else
{
val = Convert.ToInt32(boolVal);
}
}
}
return(val);
}
private ConversionState DeserializeISerializable()
{
var expectedTypeAttribute = Property.GetEnumAttribute <TypeAttribute>();
if (expectedTypeAttribute != null)
{
if (!typeof(ISerializable).IsAssignableFrom(expectedTypeAttribute.Class))
{
throw new InvalidOperationException($"Property '{Property}' has a {nameof(TypeAttribute)} of type '{expectedTypeAttribute.Class}' which does not implement '{typeof(ISerializable)}'. This represents an internal bug that must be corrected.");
}
if (OriginalValue != null)
{
//If someone specifies the ACTUALLY serialized form of a value, we don't actually support deserializing that
//(e.g. "3 days" for a ScanningInterval, however as currently designed we don't actually use deserialization
//in DynamicPropertyTypeParser for anything but transforming "normal" user input
if (expectedTypeAttribute.Class.IsAssignableFrom(ValueType))
{
Type = TypeCategory.Other;
NewValue = OriginalValue;
return(ConversionState.ValueConversion);
}
else
{
throw new InvalidTypeException($"Expected a value of type '{expectedTypeAttribute.Class}' while parsing property '{Property}' however received a value of type '{ValueType}'.");
}
}
else
{
return(ConversionState.ValueConversionWithNullCheck);
}
}
return(MoveNext());
}
public ComponentType(Type type, int size, TypeCategory category, FastEquality.Layout[] layout)
{
Type = type;
SizeInChunk = size;
Category = category;
FastEqualityLayout = layout;
}
private string GetChangeManagedNameActionResult(TypeInfo typeInfo,
ConvType convType, string oldName)
{
if (Settings.m_ruleSet != null)
{
ICategory category = TypeCategory.GetInstance();
TypeInfoMatchTarget target = null;
using (TypeAttr attr = typeInfo.GetTypeAttr())
{
TypeLibTypes.Interop.TYPEKIND kind = attr.typekind;
target = new TypeInfoMatchTarget(typeInfo.GetContainingTypeLib(), typeInfo, kind);
}
AbstractActionManager actionManager = RuleEngine.GetActionManager();
List <Rule> changeNameRules = Settings.m_ruleSet.GetRule(
category, ChangeManagedNameActionDef.GetInstance(), target);
if (changeNameRules.Count != 0)
{
if (changeNameRules.Count > 1)
{
Output.WriteWarning(Resource.FormatString("Wrn_RuleMultipleMatch",
ChangeManagedNameActionDef.GetInstance()),
WarningCode.Wrn_RuleMultipleMatch);
}
Rule changeNameRule = changeNameRules[changeNameRules.Count - 1];
int namespaceSplit = oldName.LastIndexOf('.');
string oldNamespace = "";
if (namespaceSplit != -1)
{
oldNamespace = oldName.Substring(0, namespaceSplit + 1);
}
return(oldNamespace + (changeNameRule.Action as ChangeManagedNameAction).NewName);
}
}
return(oldName);
}
public static string GetTypeCategoryDisplayString(TypeCategory type)
{
if (type == TypeCategory.StaticClass)
{
return("static class");
}
else if (type == TypeCategory.AbstractClass)
{
return("abstract class");
}
else if (type == TypeCategory.Class)
{
return("class");
}
else if (type == TypeCategory.Enum)
{
return("enum");
}
else if (type == TypeCategory.Interface)
{
return("interface");
}
else if (type == TypeCategory.Struct)
{
return("struct");
}
else
{
return(string.Empty);
}
}
public static TypePattern MapToPattern(this TypeCategory category)
{
switch (category)
{
case TypeCategory.@struct:
return(TypePattern.NonMarshalledStruct);
case TypeCategory.@enum:
case TypeCategory.bitmask:
return(TypePattern.Enum);
case TypeCategory.funcpointer:
return(TypePattern.Delegate);
case TypeCategory.None:
case TypeCategory.basetype:
return(TypePattern.Primitive);
case TypeCategory.handle:
return(TypePattern.Handle);
case TypeCategory.union:
return(TypePattern.Union);
default:
throw new NotSupportedException();
}
}
private Info(string name, NanoLocation location, TypeCategory category, Type[] genericArgs)
{
Name = name;
Location = location;
Category = category;
GenericArgs = genericArgs;
}
public SimpleType(TypeCategory category, string fullname, IEnumerable <string> attributes, IEnumerable <SimpleType> methods)
{
Category = category;
Fullname = fullname;
Attributes = attributes;
Methods = methods;
}
private void InitializeTypeReferenceGroup(PersonalDataContext ctx)
{
TypeReferenceGroup = new TypeDigest()
{
ParentType = TypeRootCategory,
Category = TypeCategoryRootCategory,
Code = "ReferenceGroup",
BCode = "ReferenceGroup",
Name = "Категория хранения типов указателей на данные (указатели на типы, данные по действиям, константы или другие типы, наследуемые от указателей)",
TypeTable = TypeTableRootCategory,
Note = null,
Edit = _defaultOpen,
Open = _defaultOpen,
Close = _defaultClose,
Order = 1
};
ctx.TypeDigests.Add(TypeReferenceGroup);
ctx.SaveChanges();
TypeCategoryReferenceGroup = new TypeCategory()
{
Id = TypeReferenceGroup.Id,
TypeTable = null
};
ctx.TypeCategories.Add(TypeCategoryReferenceGroup);
ctx.SaveChanges();
TypeReferenceType = new TypeDigest()
{
ParentType = null,
Category = TypeCategoryReferenceGroup,
Code = "TypeReference",
BCode = "TypeReference",
Name = "Указатель на типы из drType",
TypeTable = null,
Note = null,
Edit = _defaultOpen,
Open = _defaultOpen,
Close = _defaultClose,
Order = 1
};
TypeReferenceConst = new TypeDigest()
{
ParentType = null,
Category = TypeCategoryReferenceGroup,
Code = "ConstReference",
BCode = "ConstReference",
Name = "Указатель на константу",
TypeTable = null,
Note = null,
Edit = _defaultOpen,
Open = _defaultOpen,
Close = _defaultClose,
Order = 3
};
ctx.TypeDigests.AddRange(new[] { TypeReferenceType, TypeReferenceConst });
ctx.SaveChanges();
}
private void InitializeTypeExpressionNode(PersonalDataContext ctx)
{
TypeExpressionNodeCategory = new TypeDigest()
{
ParentType = TypeRootCategory,
Category = TypeCategoryRootCategory,
Code = "ExpressionNodeTypeCategory",
BCode = "ExpressionNodeTypeCategory",
Name = "Категория для типов узлов выражений",
TypeTable = TypeTableRootCategory,
Note = null,
Edit = _defaultOpen,
Open = _defaultOpen,
Close = _defaultClose,
Order = 1
};
ctx.TypeDigests.Add(TypeExpressionNodeCategory);
ctx.SaveChanges();
TypeCategoryExpressionNode = new TypeCategory()
{
Id = TypeExpressionNodeCategory.Id,
TypeTable = null
};
ctx.TypeCategories.Add(TypeCategoryExpressionNode);
ctx.SaveChanges();
TypeExpressionNodeReference = new TypeDigest()
{
ParentType = null,
Category = TypeCategoryExpressionNode,
Code = "ReferenceExpressionNode",
BCode = "ReferenceExpressionNode",
Name = "Узел хранит указатель на значение",
TypeTable = null,
Note = null,
Edit = _defaultOpen,
Open = _defaultOpen,
Close = _defaultClose,
Order = 1
};
TypeExpressionNodeOperator = new TypeDigest()
{
ParentType = null,
Category = TypeCategoryExpressionNode,
Code = "OperatorExpressionNode",
BCode = "OperatorExpressionNode",
Name = "Указатель на оператор",
TypeTable = null,
Note = null,
Edit = _defaultOpen,
Open = _defaultOpen,
Close = _defaultClose,
Order = 2
};
ctx.TypeDigests.AddRange(new[] { TypeExpressionNodeReference, TypeExpressionNodeOperator });
ctx.SaveChanges();
}
public TypeInfo(Type type, int typeIndex, int size, TypeCategory category, FastEquality.TypeInfo typeInfo, EntityOffsetInfo[] entityOffsets, EntityOffsetInfo[] blobAssetRefOffsets, ulong memoryOrdering, int bufferCapacity, int elementSize, int alignmentInBytes, ulong stableTypeHash, int *writeGroups, int writeGroupCount, int maximumChunkCapacity)
{
Type = type;
TypeIndex = typeIndex;
SizeInChunk = size;
Category = category;
FastEqualityTypeInfo = typeInfo;
EntityOffsetCount = entityOffsets?.Length ?? 0;
EntityOffsets = entityOffsets;
BlobAssetRefOffsetCount = blobAssetRefOffsets?.Length ?? 0;
BlobAssetRefOffsets = blobAssetRefOffsets;
MemoryOrdering = memoryOrdering;
BufferCapacity = bufferCapacity;
ElementSize = elementSize;
AlignmentInBytes = alignmentInBytes;
StableTypeHash = stableTypeHash;
WriteGroups = writeGroups;
WriteGroupCount = writeGroupCount;
MaximumChunkCapacity = maximumChunkCapacity;
// System state shared components are also considered system state components
bool isSystemStateSharedComponent = typeof(ISystemStateSharedComponentData).IsAssignableFrom(type);
bool isSystemStateBufferElement = typeof(ISystemStateBufferElementData).IsAssignableFrom(type);
bool isSystemStateComponent = isSystemStateSharedComponent || isSystemStateBufferElement || typeof(ISystemStateComponentData).IsAssignableFrom(type);
if (typeIndex != 0)
{
if (SizeInChunk == 0)
{
TypeIndex |= ZeroSizeTypeFlag;
}
if (Category == TypeCategory.ISharedComponentData)
{
TypeIndex |= SharedComponentTypeFlag;
}
if (isSystemStateComponent)
{
TypeIndex |= SystemStateTypeFlag;
}
if (isSystemStateSharedComponent)
{
TypeIndex |= SystemStateSharedComponentTypeFlag;
}
if (BufferCapacity >= 0)
{
TypeIndex |= BufferComponentTypeFlag;
}
if (EntityOffsetCount == 0)
{
TypeIndex |= HasNoEntityReferencesFlag;
}
}
}
private void SerializeSubValue(Type type, object value, IDataAdapter data, Type[] genericArgs)
{
int objId;
if (settings.EnableObjectCache && type.IsClass && objectsCache.TryGetValue(value, out objId))
{
data.AddIntValue(objId, ATTRIBUTE_OBJID, true);
haveReferences = true;
return;
}
Type targetType = value.GetType();
if (targetType != type)
{
int typeId;
if (!typesCache.TryGetValue(targetType, out typeId))
{
typesCache.Add(targetType, typeId = typesCache.Count + 1);
}
if (settings.EnableTypeMarkers)
{
data.AddIntValue(typeId, ATTRIBUTE_TYPE, true);
}
type = targetType;
genericArgs = type.GetGenericArguments();
}
TypeCategory category = GetTypeCategory(type);
switch (category)
{
case TypeCategory.Primitive:
data.SetStringValue(value.ToString());
break;
case TypeCategory.Enum:
if (settings.EnumsAsValue)
{
data.SetIntValue(((IConvertible)value).ToInt64(null));
}
else
{
data.SetStringValue(value.ToString());
}
break;
case TypeCategory.Unknown:
SerializeValue(data, value);
break;
default:
SerializeContainer(value, data, category, genericArgs);
break;
}
}
public ComponentType(Type type, int size, TypeCategory category, FastEquality.Layout[] layout, EntityOffsetInfo[] entityOffsets, UInt64 memoryOrdering)
{
Type = type;
SizeInChunk = size;
Category = category;
FastEqualityLayout = layout;
EntityOffsets = entityOffsets;
MemoryOrdering = memoryOrdering;
}
private object ParseNumericValue()
{
object val = null;
//If the value is convertable to a double, it is either an int or a double
if (!string.IsNullOrEmpty(OriginalValue?.ToString()))
{
double doubleResult;
//If the value is a double. Implicitly not null due to !string.IsNullOrEmpty check above
if (double.TryParse(OriginalValue.ToString(), out doubleResult))
{
//If we're actually looking for an int, see if this double is actually an integer
if (PropertyType == typeof(int))
{
if (Convert.ToInt32(doubleResult) == doubleResult)
{
//If so, that's cool. When we ToString, we'll get an integer value anyway
Type = TypeCategory.Number;
if (Mode == SerializationMode.Deserialize)
{
val = (int)doubleResult;
}
else
{
val = doubleResult.ToString(CultureInfo.CurrentCulture);
}
}
//Else: someone tried to assign an actual double to our integer. An exception will be thrown below
}
else
{
Type = TypeCategory.Number;
if (Mode == SerializationMode.Deserialize)
{
val = doubleResult;
}
else
{
val = doubleResult.ToString(CultureInfo.CurrentCulture);
}
}
}
//If we still don't have a value, since we already verified our value is not null or empty we must have a value of an invalid type
if (val == null)
{
throw GetInvalidTypeException();
}
}
return(val);
}
public static Type GetType(string typeName, TypeCategory typeCategory)
{
string strFullName = "SMT.FB.UI.Common.";
if (typeCategory == TypeCategory.EntityObject)
{
strFullName = "SMT.FB.UI.FBCommonWS.";
}
return(Type.GetType(strFullName + typeName));
}
public ComponentType(Type type, int size, TypeCategory category, FastEquality.TypeInfo typeInfo, EntityOffsetInfo[] entityOffsets, UInt64 memoryOrdering, int bufferCapacity, int elementSize)
{
Type = type;
SizeInChunk = size;
Category = category;
FastEqualityTypeInfo = typeInfo;
EntityOffsets = entityOffsets;
MemoryOrdering = memoryOrdering;
BufferCapacity = bufferCapacity;
ElementSize = elementSize;
}
public async Task <IActionResult> PostTypeCategory([FromBody] TypeCategory typeCategory)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.TypeCategories.Add(typeCategory);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetTypeCategory", new { id = typeCategory.Id_type }, typeCategory));
}
public TypeInfo(Type type, int size, TypeCategory category, FastEquality.TypeInfo typeInfo, EntityOffsetInfo[] entityOffsets, UInt64 memoryOrdering, int bufferCapacity, int elementSize)
{
Type = type;
SizeInChunk = size;
Category = category;
FastEqualityTypeInfo = typeInfo;
EntityOffsets = entityOffsets;
MemoryOrdering = memoryOrdering;
BufferCapacity = bufferCapacity;
ElementSize = elementSize;
IsSystemStateSharedComponent = typeof(ISystemStateSharedComponentData).IsAssignableFrom(type);
IsSystemStateComponent = typeof(ISystemStateComponentData).IsAssignableFrom(type);
}
TypeMetadata([NotNull] Type contractType)
{
Category = SerializationUtil.CategorizeType(contractType);
if (Category == TypeCategory.ConvertibleByProperties) {
Properties =
contractType.GetProperties()
.Where(p => !Attribute.GetCustomAttributes(p, typeof(NbtIgnoreAttribute)).Any())
.ToArray();
PropertyTagNames = new Dictionary<PropertyInfo, string>();
foreach (PropertyInfo property in Properties) {
// read [TagName] attributes
Attribute[] nameAttributes = Attribute.GetCustomAttributes(property, typeof(TagNameAttribute));
string tagName;
if (nameAttributes.Length != 0) {
tagName = ((TagNameAttribute)nameAttributes[0]).Name;
} else {
tagName = property.Name;
}
PropertyTagNames.Add(property, tagName);
// read [NullPolicy] attributes
var nullPolicyAttr =
Attribute.GetCustomAttribute(property, typeof(NullPolicyAttribute)) as NullPolicyAttribute;
if (nullPolicyAttr != null) {
if (nullPolicyAttr.SelfPolicy != NullPolicy.Default) {
if (NullPolicies == null) {
NullPolicies = new Dictionary<PropertyInfo, NullPolicy>();
}
NullPolicies.Add(property, nullPolicyAttr.SelfPolicy);
}
if (nullPolicyAttr.ElementPolicy != NullPolicy.Default) {
if (ElementNullPolicies == null) {
ElementNullPolicies = new Dictionary<PropertyInfo, NullPolicy>();
}
ElementNullPolicies.Add(property, nullPolicyAttr.ElementPolicy);
}
}
// check for presence of [NonSerialized] and [NbtIgnore] attributes
if (Attribute.IsDefined(property, typeof(NonSerializedAttribute)) ||
Attribute.IsDefined(property, typeof(NbtIgnoreAttribute))) {
if (IgnoredProperties == null) {
IgnoredProperties = new HashSet<PropertyInfo>();
}
IgnoredProperties.Add(property);
}
}
}
}
public TypeInfo(int typeIndex, TypeCategory category, int entityOffsetCount, int entityOffsetStartIndex, ulong memoryOrdering, ulong stableTypeHash, int bufferCapacity, int typeSize, int elementSize, int alignmentInBytes, bool isSystemStateComponent, bool isSystemStateSharedComponent)
{
TypeIndex = typeIndex;
Category = category;
EntityOffsetCount = entityOffsetCount;
EntityOffsetStartIndex = entityOffsetStartIndex;
//TODO: add BlobAssetRefOffset support to the static type registry
BlobAssetRefOffsetCount = 0;
BlobAssetRefOffsetStartIndex = 0;
MemoryOrdering = memoryOrdering;
StableTypeHash = stableTypeHash;
BufferCapacity = bufferCapacity;
SizeInChunk = typeSize;
AlignmentInBytes = alignmentInBytes;
ElementSize = elementSize;
if (typeIndex != 0)
{
if (SizeInChunk == 0)
{
TypeIndex |= ZeroSizeTypeFlag;
}
if (Category == TypeCategory.ISharedComponentData)
{
TypeIndex |= SharedComponentTypeFlag;
}
//System state shared components are also considered system state components
if (isSystemStateComponent || isSystemStateSharedComponent)
{
TypeIndex |= SystemStateTypeFlag;
}
if (isSystemStateSharedComponent)
{
TypeIndex |= SystemStateSharedComponentTypeFlag;
}
if (Category == TypeCategory.BufferData)
{
TypeIndex |= BufferComponentTypeFlag;
}
if (EntityOffsetCount == 0)
{
TypeIndex |= HasNoEntityReferencesFlag;
}
}
}
public TypeInfo(int typeIndex, TypeCategory category, int entityOffsetCount, int entityOffsetStartIndex, ulong memoryOrdering, ulong stableTypeHash, int bufferCapacity, int typeSize, int elementSize, int alignmentInBytes, bool isSystemStateComponent, bool isSystemStateSharedComponent)
{
TypeIndex = typeIndex;
Category = category;
EntityOffsetCount = entityOffsetCount;
EntityOffsetStartIndex = entityOffsetStartIndex;
MemoryOrdering = memoryOrdering;
StableTypeHash = stableTypeHash;
BufferCapacity = bufferCapacity;
SizeInChunk = typeSize;
AlignmentInBytes = alignmentInBytes;
ElementSize = elementSize;
IsSystemStateComponent = isSystemStateComponent;
IsSystemStateSharedComponent = isSystemStateSharedComponent;
}
public TypeInfo(Type type, int size, TypeCategory category, FastEquality.TypeInfo typeInfo, EntityOffsetInfo[] entityOffsets, ulong memoryOrdering, int bufferCapacity, int elementSize, int alignmentInBytes, ulong stableTypeHash)
{
Type = type;
SizeInChunk = size;
Category = category;
FastEqualityTypeInfo = typeInfo;
EntityOffsetCount = entityOffsets != null ? entityOffsets.Length : 0;
EntityOffsets = entityOffsets;
MemoryOrdering = memoryOrdering;
BufferCapacity = bufferCapacity;
ElementSize = elementSize;
AlignmentInBytes = alignmentInBytes;
IsSystemStateSharedComponent = typeof(ISystemStateSharedComponentData).IsAssignableFrom(type);
IsSystemStateComponent = typeof(ISystemStateComponentData).IsAssignableFrom(type);
StableTypeHash = stableTypeHash;
}
private bool RuleEngineResolveRedirection(RuleSet ruleSet, TypeInfo typeInfo,
out Type convertedType)
{
convertedType = null;
if (ruleSet != null)
{
ICategory category = TypeCategory.GetInstance();
TypeLibTypes.Interop.TYPEKIND typeKind;
using (TypeAttr attr = typeInfo.GetTypeAttr())
{
typeKind = attr.typekind;
}
TypeInfoMatchTarget target = new TypeInfoMatchTarget(typeInfo.GetContainingTypeLib(),
typeInfo, typeKind);
AbstractActionManager actionManager = RuleEngine.GetActionManager();
List <Rule> resolveToRules = ruleSet.GetRule(
category, ResolveToActionDef.GetInstance(), target);
if (resolveToRules.Count != 0)
{
if (resolveToRules.Count > 1)
{
Output.WriteWarning(Resource.FormatString("Wrn_RuleMultipleMatch",
ResolveToActionDef.GetInstance().GetActionName()),
WarningCode.Wrn_RuleMultipleMatch);
}
Rule resolveToRule =
resolveToRules[resolveToRules.Count - 1];
ResolveToAction action =
resolveToRule.Action as ResolveToAction;
try
{
Assembly assembly = Assembly.ReflectionOnlyLoad(action.AssemblyName);
convertedType = assembly.GetType(action.ManagedTypeFullName);
return(true);
}
catch (Exception)
{
Output.WriteWarning(Resource.FormatString("Wrn_CannotLoadResolveToType",
action.ManagedTypeFullName, action.AssemblyName),
WarningCode.Wrn_CannotLoadResolveToType);
}
}
}
return(false);
}
public ActionResult Update(TypeCategory model)
{
try
{
model.URL = "/" + StringUtil.UnsignToString(model.Name);
model.UpdateBy = CurrentInstance.Instance.CurrentUser.UserName;
model.UpdateDate = DateTime.Now;
_typeCatSrv.Update(model);
_typeCatSrv.CommitChange();
AlertSuccess(InfoString.UPDATE_SUCCESSFULL);
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
LogError(ex);
AlertError(InfoString.ERROR_SYSTEM);
return(View(model));
}
}
/// <summary>
/// Ensure Dispose(bool disposing) calls
/// - WriteLineIf(!disposing, MESSAGE) (if a first generation IDisposable in our code) and
/// - base.Dispose(disposing) (if a second-plus generation IDisposable of any kind)
/// </summary>
public void InspectDisposeBool(MethodBase disposeBool, Type baseType, TypeCategory baseCategory)
{
var bodyParts = new ILReader(disposeBool).ToArray();
var module = disposeBool.Module;
// If the base is any kind of Disposable, we'd better call base.Dispose()!
if (baseCategory != TypeCategory.Object && !MethodCallsBaseDispose(baseType, bodyParts, module))
{
Log.LogError(disposeBool.DeclaringType?.FullName + ".Dispose(bool disposing) should call base.Dispose(disposing);");
}
// If the base is not one of our Disposables, it is this method's responsibility to warn on missing Dispose() calls;
// make sure the Dispose(bool) method starts with a WriteLineIf
if (baseCategory != TypeCategory.Disposable &&
!MethodBeginningsMatch(WriteLineIf, bodyParts, module) && !MethodBeginningsMatch(WriteLineIf2, bodyParts, module))
{
Log.LogError(disposeBool.DeclaringType?.FullName + ".Dispose(bool disposing) should call " + MissingDisposeMsgCmd);
}
}
private ConversionState ProcessNullable()
{
//String, Int and Double can be used as is
if (PropertyType == typeof(string))
{
Type = TypeCategory.String;
NewValue = OriginalValue?.ToString();
return(ValueConversionWithMaybeNullCheck);
}
else if (PropertyType == typeof(double) || PropertyType == typeof(int))
{
NewValue = ParseNumericValue();
return(ValueConversionWithMaybeNullCheck);
}
return(MoveNext());
}
private void InitializeRootCatalog(PersonalDataContext ctx)
{
TypeTableRootCategory = new TypeTable()
{
Table = "drTypeCategory",
Name = "TypeCategory",
Note = "Категории",
PK = "idTypeCategory",
TableObjectId = null
};
ctx.TypeTables.Add(TypeTableRootCategory);
ctx.SaveChanges();
TypeRootCategory = new TypeDigest()
{
Code = "TypeCategory",
BCode = "TypeCategory",
Name = "Типы справочников (Категории)",
TypeTable = TypeTableRootCategory,
Note = null,
Edit = _defaultOpen,
Open = _defaultOpen,
Close = _defaultClose,
Order = 0
};
ctx.TypeDigests.Add(TypeRootCategory);
ctx.SaveChanges();;
TypeCategoryRootCategory = new TypeCategory()
{
Id = TypeRootCategory.Id,
TypeTable = TypeTableRootCategory
};
ctx.TypeCategories.Add(TypeCategoryRootCategory);
ctx.SaveChanges();
TypeRootCategory.Category = TypeCategoryRootCategory;
ctx.SaveChanges();
}
internal static string ToSwaggerType(this Type type, out TypeCategory category, out Type containedType, IDictionary<string, string> customTypeMappings = null)
{
if (type == typeof (HttpResponseMessage))
{
category = TypeCategory.Unkown;
containedType = null;
return null;
}
if (type == null)
{
category = TypeCategory.Primitive;
containedType = null;
return "void";
}
var primitiveTypeMap = new Dictionary<string, string>
{
{"Byte", "byte"},
{"Boolean", "boolean"},
{"Int32", "int"},
{"Int64", "long"},
{"Single", "float"},
{"Double", "double"},
{"Decimal", "double"},
{"String", "string"},
{"DateTime", "date"}
};
if (customTypeMappings != null)
primitiveTypeMap = primitiveTypeMap.Concat(customTypeMappings).ToDictionary(m => m.Key, m => m.Value);
if (primitiveTypeMap.ContainsKey(type.Name))
{
category = TypeCategory.Primitive;
containedType = null;
return primitiveTypeMap[type.Name];
}
Type innerTypeOfNullable;
if (type.IsNullableType(out innerTypeOfNullable))
{
return innerTypeOfNullable.ToSwaggerType(out category, out containedType);
}
if (type.IsEnum)
{
category = TypeCategory.Primitive;
containedType = null;
return "string";
}
var enumerable = type.AsGenericType(typeof(IEnumerable<>));
if (enumerable != null)
{
category = TypeCategory.Container;
containedType = enumerable.GetGenericArguments().First();
return String.Format("List[{0}]", containedType.ToSwaggerType(customTypeMappings));
}
category = TypeCategory.Complex;
containedType = null;
return type.Name;
}
private string CategoryName(TypeCategory category)
{
switch (category)
{
case TypeCategory.Interface: return "Interfaces";
case TypeCategory.Class: return "Classes";
case TypeCategory.Delegate: return "Delegates";
case TypeCategory.Enum: return "Enums";
default:
throw new ArgumentException("Invalid category", "category");
}
}
private int IntVal(TypeCategory category)
{
switch (category)
{
case TypeCategory.Class: return 0;
case TypeCategory.Interface: return 1;
case TypeCategory.Enum: return 2;
case TypeCategory.Delegate: return 3;
default:
throw new ArgumentException("Invalid category", "category");
}
}
