private void GenerateFieldSelectionSet(
OperationDefinitionNode operation,
IType fieldType,
FieldNode fieldSelection,
Path path,
Queue <FieldSelection> backlog)
{
INamedType namedType = fieldType.NamedType();
IReadOnlyCollection <ObjectType> possibleTypes =
namedType is ObjectType ot
? new ObjectType[] { ot }
: _schema.GetPossibleTypes(namedType);
var typeCases = new Dictionary <ObjectType, FieldCollectionResult>();
foreach (ObjectType objectType in possibleTypes)
{
FieldCollectionResult typeCase = _fieldCollector.CollectFields(
objectType,
fieldSelection.SelectionSet,
path);
EnqueueFields(backlog, typeCase.Fields);
typeCases[objectType] = typeCase;
}
if (namedType is UnionType unionType)
{
_fieldTypes[fieldSelection] = GenerateUnionSelectionSet(
operation,
unionType,
fieldType,
fieldSelection,
typeCases.Values,
path);
}
else if (namedType is InterfaceType interfaceType)
{
_fieldTypes[fieldSelection] = GenerateInterfaceSelectionSet(
operation,
interfaceType,
fieldType,
fieldSelection,
typeCases.Values,
path);
}
else if (namedType is ObjectType objectType)
{
_fieldTypes[fieldSelection] = GenerateObjectSelectionSet(
operation,
objectType,
fieldType,
fieldSelection,
typeCases.Values.Single(),
path);
}
}
private ICodeDescriptor GenerateObjectSelectionSet(
OperationDefinitionNode operation,
ObjectType objectType,
IType fieldType,
WithDirectives fieldOrOperation,
FieldCollectionResult typeCase,
Path path)
{
IFragmentNode returnType = HoistFragment(
objectType, typeCase.SelectionSet, typeCase.Fragments);
IReadOnlyList <IFragmentNode> fragments;
string className;
if (returnType is null)
{
fragments = typeCase.Fragments;
className = CreateName(fieldOrOperation, objectType, GetClassName);
}
else
{
fragments = returnType.Children;
className = CreateName(GetClassName(returnType.Fragment.Name));
}
var modelSelectionSet = new SelectionSetNode(
typeCase.Fields.Select(t => t.Selection).ToList());
var modelFragment = new FragmentNode(new Fragment(
className, objectType, modelSelectionSet));
modelFragment.Children.AddRange(fragments);
IInterfaceDescriptor modelInterface =
CreateInterface(modelFragment, path);
var modelClass = new ClassDescriptor(
className, _namespace, typeCase.Type, modelInterface);
RegisterDescriptor(modelInterface);
RegisterDescriptor(modelClass);
RegisterDescriptor(
new ResultParserMethodDescriptor(
GetPathName(path),
operation,
fieldType,
fieldOrOperation as FieldNode,
path,
modelInterface,
new[] { new ResultParserTypeDescriptor(modelClass) }));
return(modelInterface);
}
private static string GetField(FieldCollectionResult value, string fieldName)
{
Field field = value.Values.FirstOrDefault(x => x.FieldId == fieldName);
if (field == null)
{
return(null);
}
return(field.Value);
}
private ICodeDescriptor GenerateInterfaceSelectionSet(
OperationDefinitionNode operation,
InterfaceType interfaceType,
IType fieldType,
FieldNode fieldSelection,
IReadOnlyCollection <FieldCollectionResult> typeCases,
Path path)
{
FieldCollectionResult firstCase = typeCases.First();
IFragmentNode returnType = HoistFragment(
interfaceType, firstCase.SelectionSet, firstCase.Fragments);
InterfaceDescriptor interfaceDescriptor;
if (returnType is null)
{
firstCase = _fieldCollector.CollectFields(
interfaceType, firstCase.SelectionSet, path);
string name = CreateName(fieldSelection, interfaceType, GetClassName);
var interfaceSelectionSet = new SelectionSetNode(
firstCase.Fields.Select(t => t.Selection).ToList());
returnType = new FragmentNode(new Fragment(
name, interfaceType, interfaceSelectionSet));
_usedNames.Remove(name);
}
interfaceDescriptor = CreateInterface(returnType, path);
var resultParserTypes = new List <ResultParserTypeDescriptor>();
foreach (FieldCollectionResult typeCase in typeCases)
{
GenerateInterfaceTypeCaseModel(
typeCase, returnType, resultParserTypes, path);
}
RegisterDescriptor(interfaceDescriptor);
RegisterDescriptor(
new ResultParserMethodDescriptor(
GetPathName(path),
operation,
fieldType,
fieldSelection,
path,
interfaceDescriptor,
resultParserTypes));
return(interfaceDescriptor);
}
//private TimeZoneInfo GetTimeZone(CommonInfo commonInfo)
//{
// TimeZoneInfo result = null;
// if (!string.IsNullOrEmpty(commonInfo.TimeZoneJavaId))
// {
// result = GetTimeZoneInfoForTzdbId(commonInfo.TimeZoneJavaId);
// }
// if (result != null)
// return result;
// var mapping = ACDetailsDTO.TimeZones.First(x => x.Id == commonInfo.TimeZoneId);
// result = FindSystemTimeZoneByIdOrDefault(mapping.WindowsTimeZoneId);
// if (result != null)
// return result;
// var timeZoneName = $"Custom time zone: {mapping.BaseUtcOffset}";
// result = TimeZoneInfo.CreateCustomTimeZone(
// timeZoneName,
// TimeSpan.FromMinutes((double)mapping.BaseUtcOffset),
// timeZoneName,
// timeZoneName);
// return result;
//}
//private TimeZoneInfo GetTimeZoneInfoForTzdbId(string tzdbId)
//{
// var olsonMappings = TzdbDateTimeZoneSource.Default.WindowsMapping.MapZones;
// var map = olsonMappings.FirstOrDefault(x =>
// x.TzdbIds.Any(z => z.Equals(tzdbId, StringComparison.OrdinalIgnoreCase)));
// return map != null ? FindSystemTimeZoneByIdOrDefault(map.WindowsId) : null;
//}
//private TimeZoneInfo FindSystemTimeZoneByIdOrDefault(string timezoneId)
//{
// try
// {
// return TimeZoneInfo.FindSystemTimeZoneById(timezoneId);
// }
// catch (TimeZoneNotFoundException e)
// {
// _logger.Error($"Timezone not found. Id: {timezoneId}", e);
// return null;
// }
//}
private static CustomizationDTO ParseCustomization(FieldCollectionResult fields, IAdobeConnectProxy provider)
{
var logo = new Uri(provider.AdobeConnectRoot, "/webappBanner/custom/images/logos/banner_logo.png");
return(new CustomizationDTO
{
AccountBannerColor = GetField(fields, "account-banner-color") ?? "FFFFFF",
BannerTopLinkColor = GetField(fields, "banner-top-link-color") ?? "666666",
BannerNavTextColor = GetField(fields, "banner-nav-text-color") ?? "666666",
BannerNavSelColor = GetField(fields, "banner-nav-sel-color") ?? "E9E9E9",
AccountHeaderColor = GetField(fields, "account-header-color") ?? "A7ACB1",
BannerLogoUrl = logo.ToString(),
});
}
private void GenerateInterfaceTypeCaseModel(
FieldCollectionResult typeCase,
IFragmentNode returnType,
ICollection <ResultParserTypeDescriptor> resultParser,
Path path)
{
string className;
IReadOnlyList <IFragmentNode> fragments;
IFragmentNode modelType = HoistFragment(
(ObjectType)typeCase.Type,
typeCase.SelectionSet,
typeCase.Fragments);
if (modelType is null)
{
fragments = typeCase.Fragments;
className = CreateName(GetClassName(typeCase.Type.Name));
}
else
{
fragments = modelType.Children;
className = CreateName(GetClassName(modelType.Fragment.Name));
}
var modelSelectionSet = new SelectionSetNode(
typeCase.Fields.Select(t => t.Selection).ToList());
var modelFragment = new FragmentNode(new Fragment(
className, typeCase.Type, modelSelectionSet));
modelFragment.Children.AddRange(fragments);
if (modelFragment.Children.All(t =>
t.Fragment.SelectionSet != returnType.Fragment.SelectionSet))
{
modelFragment.Children.Add(returnType);
}
IInterfaceDescriptor modelInterface =
CreateInterface(modelFragment, path);
var modelClass = new ClassDescriptor(
className, _namespace, typeCase.Type, modelInterface);
RegisterDescriptor(modelInterface);
RegisterDescriptor(modelClass);
resultParser.Add(new ResultParserTypeDescriptor(modelClass));
}
public ACDetailsDTO GetAccountDetails(IAdobeConnectProxy provider)
{
if (provider == null)
{
throw new ArgumentNullException(nameof(provider));
}
CommonInfoResult commonInfo = provider.GetCommonInfo();
if (!commonInfo.Success)
{
_logger.ErrorFormat("GetAccountDetails.GetCommonInfo. AC error:{0}.", commonInfo.Status.GetErrorInfo());
return(null);
}
if (commonInfo.CommonInfo.AccountId.HasValue)
{
FieldCollectionResult fields = provider.GetAclFields(commonInfo.CommonInfo.AccountId.Value);
if (fields.Status.Code != StatusCodes.ok)
{
_logger.ErrorFormat("GetAccountDetails.GetAclFields. AC error. Code:{0}.SubCode:{1}.", fields.Status.Code, fields.Status.SubCode);
return(null);
}
var dto = new ACDetailsDTO
{
Version = commonInfo.CommonInfo.Version,
PasswordPolicies = ParsePasswordPolicies(fields),
Customization = ParseCustomization(fields, provider),
TimeZoneJavaId = commonInfo.CommonInfo.TimeZoneJavaId,
};
//var timeZone = GetTimeZone(commonInfo.CommonInfo);
int session;
int.TryParse(GetField(fields, "web-session-timeout-minutes"), out session);
dto.SessionTimeout = session;
//dto.SetTimeZone(timeZone);
return(dto);
}
_logger.Error("GetAccountDetails. Account is NULL");
return(null);
}
private static ACPasswordPoliciesDTO ParsePasswordPolicies(FieldCollectionResult fields)
{
bool passwordRequiresDigit = "YES".Equals(GetField(fields, "password-requires-digit"), StringComparison.OrdinalIgnoreCase);
bool passwordRequiresCapitalLetter = "YES".Equals(GetField(fields, "password-requires-capital-letter"), StringComparison.OrdinalIgnoreCase);
string passwordRequiresSpecialChars = GetField(fields, "password-requires-special-chars");
int passwordMinLength = int.Parse(GetField(fields, "password-min-length") ?? "4");
int passwordMaxLength = int.Parse(GetField(fields, "password-max-length") ?? "32");
var loginSameAsEmailField = GetField(fields, "login-same-as-email");
bool loginSameAsEmail = string.IsNullOrEmpty(loginSameAsEmailField) ||
"YES".Equals(loginSameAsEmailField, StringComparison.OrdinalIgnoreCase);
return(new ACPasswordPoliciesDTO
{
PasswordRequiresDigit = passwordRequiresDigit,
PasswordRequiresCapitalLetter = passwordRequiresCapitalLetter,
PasswordRequiresSpecialChars = passwordRequiresSpecialChars,
PasswordMinLength = passwordMinLength,
PasswordMaxLength = passwordMaxLength,
LoginSameAsEmail = loginSameAsEmail,
});
}
private ICodeDescriptor GenerateOperationSelectionSet(
ObjectType operationType,
OperationDefinitionNode operation,
Path path,
Queue <FieldSelection> backlog)
{
FieldCollectionResult typeCase = _fieldCollector.CollectFields(
operationType,
operation.SelectionSet,
path);
EnqueueFields(backlog, typeCase.Fields);
return(_operationTypes[operation] =
GenerateObjectSelectionSet(
operation,
operationType,
operationType,
operation,
typeCase,
path));
}
private ICodeDescriptor GenerateUnionSelectionSet(
OperationDefinitionNode operation,
UnionType unionType,
IType fieldType,
FieldNode fieldSelection,
IReadOnlyCollection <FieldCollectionResult> typeCases,
Path path)
{
IFragmentNode returnType = null;
FieldCollectionResult result = typeCases.First();
IReadOnlyList <IFragmentNode> fragments = result.Fragments;
while (fragments.Count == 1)
{
if (fragments[0].Fragment.TypeCondition == unionType)
{
returnType = fragments[0];
fragments = fragments[0].Children;
}
else
{
break;
}
}
InterfaceDescriptor unionInterface;
if (returnType is null)
{
string name = CreateName(
fieldSelection,
unionType,
Utilities.NameUtils.GetInterfaceName);
unionInterface = new InterfaceDescriptor(
name, _namespace, unionType);
}
else
{
unionInterface = CreateInterface(returnType, path);
unionInterface = unionInterface.RemoveAllImplements();
}
var resultParserTypes = new List <ResultParserTypeDescriptor>();
foreach (var typeCase in typeCases)
{
string className;
string interfaceName;
IFragmentNode fragment = typeCase.Fragments.FirstOrDefault(
t => t.Fragment.TypeCondition == typeCase.Type);
if (fragment is null)
{
className = CreateName(typeCase.Type.Name);
interfaceName = CreateName(GetInterfaceName(className));
}
else
{
className = CreateName(fragment.Fragment.Name);
interfaceName = CreateName(GetInterfaceName(fragment.Fragment.Name));
}
var modelInterfaces = new List <IInterfaceDescriptor>();
modelInterfaces.Add(
new InterfaceDescriptor(
interfaceName,
_namespace,
typeCase.Type,
typeCase.Fields.Select(t =>
{
string responseName = (t.Selection.Alias ?? t.Selection.Name).Value;
return(new FieldDescriptor(
t.Field,
t.Selection,
t.Field.Type,
t.Path.Append(responseName)));
}).ToList(),
new[] { unionInterface }));
modelInterfaces.AddRange(CreateInterfaces(typeCase.Fragments, path));
var modelClass = new ClassDescriptor(
className, _namespace, typeCase.Type, modelInterfaces);
RegisterDescriptors(modelInterfaces);
RegisterDescriptor(modelClass);
resultParserTypes.Add(new ResultParserTypeDescriptor(modelClass));
}
RegisterDescriptor(unionInterface);
RegisterDescriptor(
new ResultParserMethodDescriptor(
GetPathName(path),
operation,
fieldType,
fieldSelection,
path,
unionInterface,
resultParserTypes));
return(unionInterface);
}
public bool TestACConnection(ConnectionTestDTO test, out string info,
out bool loginSameAsEmail)
{
if (test == null)
{
throw new ArgumentNullException(nameof(test));
}
loginSameAsEmail = false;
//sharedTemplatesFolderScoId = null;
info = string.Empty;
if (string.IsNullOrWhiteSpace(test.password))
{
info = "Password is required";
return(false);
}
if (!TestDomainFormat(test, out info))
{
return(false);
}
var provider = new AdobeConnectProvider(new ConnectionDetails(new Uri(test.domain)));
var result = provider.Login(new UserCredentials(test.login, test.password));
if (!result.Success)
{
string error = FormatErrorFromAC(result);
if (!string.IsNullOrWhiteSpace(error))
{
info = error;
}
return(false);
}
CommonInfoResult commonInfo = provider.GetCommonInfo();
if (!commonInfo.Success)
{
_logger.ErrorFormat("GetPasswordPolicies.GetUserInfo. AC error. {0}.", commonInfo.Status.GetErrorInfo());
info = commonInfo.Status.GetErrorInfo();
return(false);
}
if (commonInfo.CommonInfo.AccountId.HasValue)
{
FieldCollectionResult fields = provider.GetAclFields(commonInfo.CommonInfo.AccountId.Value);
if (!fields.Success)
{
_logger.ErrorFormat("GetPasswordPolicies.GetAclFields. AC error. {0}.", fields.Status.GetErrorInfo());
info = fields.Status.GetErrorInfo();
return(false);
}
//ScoContentCollectionResult sharedTemplates = provider.GetContentsByType("shared-meeting-templates");
//if (!sharedTemplates.Success)
//{
// logger.ErrorFormat("GetPasswordPolicies.get shared-meeting-templates. AC error. {0}.", sharedTemplates.Status.GetErrorInfo());
// info = sharedTemplates.Status.GetErrorInfo();
// return false;
//}
//sharedTemplatesFolderScoId = sharedTemplates.ScoId;
string setting = GetField(fields, "login-same-as-email");
loginSameAsEmail = string.IsNullOrEmpty(setting) || "YES".Equals(setting, StringComparison.OrdinalIgnoreCase);
return(true);
}
_logger.Error("GetPasswordPolicies. Account is NULL. Check Adobe Connect account permissions. Admin account expected.");
info = "Check Adobe Connect account permissions. Admin account expected.";
return(false);
}
