public JObject ToJson()
{
var json = new JObject
{
{ EVENT_ID_KEY, _eventId },
{ START_TIME_KEY, _startTime },
{ END_TIME_KEY, _endTime },
{ NAME_KEY, _name },
{ ATTRIBUTES_KEY, _attributes },
{ SESSION_ID_KEY, _sessionId },
{ SEQUENCE_ID_KEY, _sequenceId },
{ SENDER_ID_KEY, _senderId },
{ SENDER_CONTEXT_KEY, _senderContext },
{ SCHEMA_TYPE_KEY, _schemaType.ToString() },
{ EVENT_TYPE_KEY, _eventType.ToString() },
{ ERROR_TYPE_KEY, _errorType.ToString() },
{ CONNECTION_TYPE_KEY, _connectionType },
{ DEVICE_APP_ATTRIBUTES_KEY, _deviceAppAttributes.ToJson() },
{ SENDER_PARENT_ID_KEY, _senderParentId },
{ SESSION_START_TIME_KEY, _sessionStartTime },
{ PAGE_KEY, _page },
{ PREVIOUS_PAGE_KEY, _previousPage },
{ MARKS_KEY, _marks }
};
return(json);
}
public override void AddRecoveryData(Dictionary <string, string> rec)
{
//call base
base.AddRecoveryData(rec);
rec[C.TYPE_ID_KEY] = nameof(SyncList); //override with this class' name
rec.Add(nameof(schemaType), schemaType.ToString());
rec.Add(nameof(schemaParams), Utils.EncodeSequence(schemaParams));
}
/// <summary>
/// A generic method to serialize primitive Baiji types.
/// </summary>
/// <typeparam name="S">Type of the C# type to be serialized</typeparam>
/// <param name="value">The value to be serialized</param>
/// <param name="tag">The schema type tag</param>
/// <param name="writer">The writer which should be used to write the given type.</param>
protected void Write <S>(object value, SchemaType tag, Action <S> writer)
{
if (!(value is S))
{
throw TypeMismatch(value, tag.ToString(), typeof(S).ToString());
}
writer((S)value);
}
// IDataAdapter.FillSchema
internal static ArgumentOutOfRangeException InvalidSchemaType(SchemaType value)
{
#if DEBUG
switch (value)
{
case SchemaType.Source:
case SchemaType.Mapped:
Debug.Assert(false, "valid SchemaType " + value.ToString());
break;
}
#endif
return(InvalidEnumerationValue(typeof(SchemaType), (int)value));
}
private static string SchemaTypeToString(SchemaType objType)
{
string result = string.Empty;
if (((objType & SchemaType.Users) == SchemaType.Unspecified) ||
((objType & SchemaType.Organizations) == SchemaType.Unspecified) ||
((objType & SchemaType.Groups) == SchemaType.Unspecified))
{
result = objType.ToString().ToUpper();
}
return(result);
}
internal static string SchemaTypeToPrefix(this SchemaType schemaType)
{
string cacheKey = "OguAndADObjectComparerBasePrefix" + "-" + schemaType.ToString();
return((string)ObjectContextCache.Instance.GetOrAddNewValue(cacheKey, (cache, key) =>
{
string prefix = PermissionCenterToADSynchronizeSettings.GetConfig().SchemaMappings.GetSchemaMappingInfo(schemaType.ToString()).Prefix;
cache.Add(cacheKey, prefix);
return prefix;
}));
}
public async Task <SchemaVersion> GetLastRevisionAsync(SchemaType type, string @namespace, string name)
{
var query = await _repository.RetrieveAsync(q => q
.Where(x =>
x.Type.ToString() ==
type.ToString() && // Azure SDK does not respect serializer settings: force conversion
x.Namespace == @namespace &&
x.Name == name)
.OrderByDescending(x => x.Revision));
var lastRevision = query.FirstOrDefault();
return(lastRevision?.Model);
}
private static OguAndADObjectSetterBase GetSetter(ObjectModifyType modifyType, SchemaType schemaType)
{
string schemaTypeName = schemaType.ToString();
string cacheKey = "OguAndADObjectSetterBase" + "-" + modifyType.ToString() + "+" + schemaTypeName;
return (OguAndADObjectSetterBase)ObjectContextCache.Instance.GetOrAddNewValue(cacheKey, (cache, key) =>
{
SchemaMappingInfo mappingInfo = PermissionCenterToADSynchronizeSettings.GetConfig().SchemaMappings.GetSchemaMappingInfo(schemaTypeName);
OguAndADObjectSetterBase setter = null;
if (mappingInfo.ModifyOperations.ContainsKey(modifyType.ToString()))
{
SetterObjectMappingConfigurationElement objSetterMappingElement = mappingInfo.ModifyOperations[modifyType.ToString()];
setter = (OguAndADObjectSetterBase)PropertySettersSettings.GetConfig().ObjectSetters[objSetterMappingElement.OperationName].CreateInstance();
}
cache.Add(cacheKey, setter);
return setter;
});
}
private static OguAndADObjectSetterBase GetSetter(ObjectModifyType modifyType, SchemaType schemaType)
{
string schemaTypeName = schemaType.ToString();
string cacheKey = "OguAndADObjectSetterBase" + "-" + modifyType.ToString() + "+" + schemaTypeName;
return((OguAndADObjectSetterBase)ObjectContextCache.Instance.GetOrAddNewValue(cacheKey, (cache, key) =>
{
SchemaMappingInfo mappingInfo = PermissionCenterToADSynchronizeSettings.GetConfig().SchemaMappings.GetSchemaMappingInfo(schemaTypeName);
OguAndADObjectSetterBase setter = null;
if (mappingInfo.ModifyOperations.ContainsKey(modifyType.ToString()))
{
SetterObjectMappingConfigurationElement objSetterMappingElement = mappingInfo.ModifyOperations[modifyType.ToString()];
setter = (OguAndADObjectSetterBase)PropertySettersSettings.GetConfig().ObjectSetters[objSetterMappingElement.OperationName].CreateInstance();
}
cache.Add(cacheKey, setter);
return setter;
}));
}
/// <summary>
/// 创建机构人员组对象
/// </summary>
/// <param name="type">需要创建的对象类型</param>
/// <returns></returns>
public IOguObject CreateObject(SchemaType type)
{
OguBaseImpl oBase = null;
switch (type)
{
case SchemaType.Users:
oBase = new OguUserImpl();
break;
case SchemaType.Organizations:
oBase = new OguOrganizationImpl();
break;
case SchemaType.OrganizationsInRole:
oBase = new OguOrganizationInRoleImpl();
break;
case SchemaType.Groups:
oBase = new OguGroupImpl();
break;
default:
throw new InvalidOperationException(string.Format(Resource.InvalidObjectTypeCreation, type.ToString()));
}
return oBase;
}
public string Generate(JsonSchema rootSchema)
{
_additionalTypesRequiredList.Clear();
if (_settings.GenerateCloningCode)
{
_kindEnumName = _settings.SchemaName + "NodeKind" + _settings.TypeNameSuffix;
_nodeInterfaceName = "I" + _settings.SchemaName + "Node" + _settings.TypeNameSuffix;
}
_rootSchema = JsonSchema.Collapse(rootSchema);
if (_fileSystem.DirectoryExists(_settings.OutputDirectory) && !_settings.ForceOverwrite)
{
throw Error.CreateException(Resources.ErrorOutputDirectoryExists, _settings.OutputDirectory);
}
_fileSystem.CreateDirectory(_settings.OutputDirectory);
SchemaType rootSchemaType = _rootSchema.SafeGetType();
if (rootSchemaType != SchemaType.Object)
{
throw Error.CreateException(Resources.ErrorNotAnObject, rootSchemaType.ToString().ToLowerInvariant());
}
string rootFileText = GenerateClass(_settings.RootClassName, _rootSchema, _settings.SealClasses, _settings.TypeNameSuffix);
if (_settings.GenerateEqualityComparers)
{
GenerateEqualityComparer(_settings.RootClassName, _rootSchema);
}
if (_rootSchema.Definitions != null)
{
List <KeyValuePair <string, JsonSchema> > typeDefinitions = _rootSchema.Definitions.Where(ShouldGenerateType).ToList();
GenerateClassesForDefinitions(typeDefinitions);
if (_settings.GenerateEqualityComparers)
{
GenerateEqualityComparers(typeDefinitions);
}
}
foreach (AdditionalTypeRequiredInfo additionalTypeRequiredInfo in _additionalTypesRequiredList)
{
GenerateAdditionalType(additionalTypeRequiredInfo.Hint, additionalTypeRequiredInfo.Schema);
}
if (_settings.GenerateCloningCode)
{
_pathToFileContentsDictionary[_nodeInterfaceName + _settings.TypeNameSuffix] =
GenerateSyntaxInterface(_settings.SchemaName, _kindEnumName, _nodeInterfaceName);
_pathToFileContentsDictionary[_kindEnumName + _settings.TypeNameSuffix] =
GenerateKindEnum(_kindEnumName);
string rewritingVisitorClassName = _settings.SchemaName + "RewritingVisitor" + _settings.TypeNameSuffix;
_pathToFileContentsDictionary[rewritingVisitorClassName] =
new RewritingVisitorGenerator(
_classInfoDictionary,
_settings.CopyrightNotice,
_settings.SuffixedNamespaceName,
rewritingVisitorClassName,
_settings.SchemaName,
_kindEnumName,
_nodeInterfaceName,
_generatedClassNames)
.GenerateRewritingVisitor();
}
foreach (KeyValuePair <string, string> entry in _pathToFileContentsDictionary)
{
_fileSystem.WriteAllText(Path.Combine(_settings.OutputDirectory, entry.Key + ".cs"), entry.Value);
}
// Returning the text of the file generated from the root schema allows this method
// to be more easily unit tested.
return(rootFileText);
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
switch (TypeCode)
{
case XmlTypeCode.AnyAtomicType:
sb.Append("AnyAtomicType");
break;
case XmlTypeCode.UntypedAtomic:
sb.Append("UntypedAtomic");
break;
case XmlTypeCode.None:
sb.Append("empty-sequence()");
break;
case XmlTypeCode.Item:
sb.Append("item()");
break;
case XmlTypeCode.Node:
sb.Append("node()");
break;
case XmlTypeCode.Document:
sb.Append("document-node(");
if (SchemaElement == null)
{
if (!NameTest.IsWildcard || SchemaType != null)
{
sb.Append("element(");
sb.Append(NameTest.ToString());
if (SchemaType != null)
{
sb.Append(",");
sb.Append(SchemaType.ToString());
if (Nillable)
{
sb.Append("?");
}
}
else
{
sb.Append(", xs:untyped");
}
sb.Append(")");
}
}
else
{
sb.Append("schema-element(");
sb.Append(SchemaElement.QualifiedName);
sb.Append(")");
}
sb.Append(")");
break;
case XmlTypeCode.Element:
if (SchemaElement == null)
{
sb.Append("element(");
sb.Append(NameTest.ToString());
if (SchemaType != null)
{
sb.Append(",");
sb.Append(SchemaType.ToString());
if (Nillable)
{
sb.Append("?");
}
}
else
{
sb.Append(", xs:untyped");
}
}
else
{
sb.Append("schema-element(");
sb.Append(SchemaElement.QualifiedName);
}
sb.Append(")");
break;
case XmlTypeCode.Attribute:
if (SchemaAttribute == null)
{
sb.Append("attribute(");
sb.Append(NameTest.ToString());
if (SchemaType != null)
{
sb.Append(",");
sb.Append(SchemaType.ToString());
}
}
else
{
sb.Append("schema-attribute(");
sb.Append(SchemaAttribute.QualifiedName);
}
sb.Append(")");
break;
case XmlTypeCode.ProcessingInstruction:
sb.Append("processing-instruction(");
break;
case XmlTypeCode.Comment:
sb.Append("comment()");
break;
case XmlTypeCode.Text:
sb.Append("text()");
break;
case XmlTypeCode.String:
sb.Append("xs:string");
break;
case XmlTypeCode.Boolean:
sb.Append("xs:boolean");
break;
case XmlTypeCode.Decimal:
sb.Append("xs:decimal");
break;
case XmlTypeCode.Float:
sb.Append("xs:float");
break;
case XmlTypeCode.Double:
sb.Append("xs:double");
break;
case XmlTypeCode.Duration:
sb.Append("xs:Duration");
break;
case XmlTypeCode.DateTime:
sb.Append("xs:dateTime");
break;
case XmlTypeCode.Time:
sb.Append("xs:time");
break;
case XmlTypeCode.Date:
sb.Append("xs:date");
break;
case XmlTypeCode.GYearMonth:
sb.Append("xs:gYearMonth");
break;
case XmlTypeCode.GYear:
sb.Append("xs:gYear");
break;
case XmlTypeCode.GMonthDay:
sb.Append("xs:gMonthDay");
break;
case XmlTypeCode.GDay:
sb.Append("xs:gDay");
break;
case XmlTypeCode.GMonth:
sb.Append("xs:gMonth");
break;
case XmlTypeCode.HexBinary:
sb.Append("xs:hexBinary");
break;
case XmlTypeCode.Base64Binary:
sb.Append("xs:base64Binary");
break;
case XmlTypeCode.AnyUri:
sb.Append("xs:anyURI");
break;
case XmlTypeCode.QName:
sb.Append("xs:QName");
break;
case XmlTypeCode.Notation:
sb.Append("xs:NOTATION");
break;
case XmlTypeCode.NormalizedString:
sb.Append("xs:normalizedString");
break;
case XmlTypeCode.Token:
sb.Append("xs:token");
break;
case XmlTypeCode.Language:
sb.Append("xs:language");
break;
case XmlTypeCode.NmToken:
if (SchemaType == XmlSchema.NMTOKENS)
{
sb.Append("xs:NMTOKENS");
}
else
{
sb.Append("xs:NMTOKEN");
}
break;
case XmlTypeCode.Name:
sb.Append("xs:Name");
break;
case XmlTypeCode.NCName:
sb.Append("xs:NCName");
break;
case XmlTypeCode.Id:
sb.Append("xs:ID");
break;
case XmlTypeCode.Idref:
if (SchemaType == XmlSchema.IDREFS)
{
sb.Append("xs:IDREFS");
}
else
{
sb.Append("xs:IDREF");
}
break;
case XmlTypeCode.Entity:
if (SchemaType == XmlSchema.ENTITIES)
{
sb.Append("xs:ENTITYS");
}
else
{
sb.Append("xs:ENTITY");
}
break;
case XmlTypeCode.Integer:
sb.Append("xs:integer");
break;
case XmlTypeCode.NonPositiveInteger:
sb.Append("xs:nonPositiveInteger");
break;
case XmlTypeCode.NegativeInteger:
sb.Append("xs:negativeInteger");
break;
case XmlTypeCode.Long:
sb.Append("xs:long");
break;
case XmlTypeCode.Int:
sb.Append("xs:int");
break;
case XmlTypeCode.Short:
sb.Append("xs:short");
break;
case XmlTypeCode.Byte:
sb.Append("xs:byte");
break;
case XmlTypeCode.NonNegativeInteger:
sb.Append("xs:nonNegativeInteger");
break;
case XmlTypeCode.UnsignedLong:
sb.Append("xs:unsignedLong");
break;
case XmlTypeCode.UnsignedInt:
sb.Append("xs:unsignedInt");
break;
case XmlTypeCode.UnsignedShort:
sb.Append("xs:unsignedShort");
break;
case XmlTypeCode.UnsignedByte:
sb.Append("xs:unsignedByte");
break;
case XmlTypeCode.PositiveInteger:
sb.Append("xs:positiveInteger");
break;
case XmlTypeCode.DayTimeDuration:
sb.Append("xs:dayTimeDuration");
break;
case XmlTypeCode.YearMonthDuration:
sb.Append("xs:yearMonthDuration");
break;
default:
sb.Append("[]");
break;
}
switch (Cardinality)
{
case XmlTypeCardinality.OneOrMore:
sb.Append("+");
break;
case XmlTypeCardinality.ZeroOrMore:
sb.Append("*");
break;
case XmlTypeCardinality.ZeroOrOne:
sb.Append("?");
break;
}
return(sb.ToString());
}
/// <summary>
/// Returns symbol name for the given schema type
/// </summary>
/// <param name="type">schema type</param>
/// <returns>symbol name</returns>
private static string GetTypeString(SchemaType type)
{
return(type != SchemaType.Enumeration ? type.ToString().ToLower() : "enum");
}
/// <summary>
/// 创建机构人员组对象
/// </summary>
/// <param name="type">需要创建的对象类型</param>
/// <returns></returns>
public IOguObject CreateObject(SchemaType type)
{
OguBaseImpl oBase = null;
switch (type)
{
case SchemaType.Users:
oBase = new OguUserImpl();
break;
case SchemaType.Organizations:
oBase = new OguOrganizationImpl();
break;
case SchemaType.OrganizationsInRole:
oBase = new OguOrganizationInRoleImpl();
break;
case SchemaType.Groups:
oBase = new OguGroupImpl();
break;
default:
throw new InvalidOperationException(string.Format(Resource.InvalidObjectTypeCreation, type.ToString()));
}
return(oBase);
}
public static void Convert(ObjectModifyType modifyType, IOguObject srcObject, DirectoryEntry targetObject)
{
SchemaType schemaType = GetOguSchemaType(targetObject);
OguAndADObjectSetterBase setter = GetSetter(modifyType, schemaType);
if (setter != null)
{
SchemaMappingInfo mappingInfo = PermissionCenterToADSynchronizeSettings.GetConfig().SchemaMappings.GetSchemaMappingInfo(schemaType.ToString());
string context = string.Empty;
if (mappingInfo.ModifyOperations.ContainsKey(modifyType.ToString()))
{
SetterObjectMappingConfigurationElement objSetterMappingElement = mappingInfo.ModifyOperations[modifyType.ToString()];
context = objSetterMappingElement.Context;
}
setter.Convert(modifyType, srcObject, targetObject, context);
}
}
