public async override Task ExecuteCommand()
{
CalculateEffectivePackageSaveMode();
string installPath = ResolveInstallPath();
var packageSourceProvider = new NuGet.Configuration.PackageSourceProvider(Settings);
var sourceRepositoryProvider = new SourceRepositoryProvider(packageSourceProvider, ResourceProviders);
IEnumerable<SourceRepository> primarySources;
IEnumerable<SourceRepository> secondarySources;
GetEffectiveSources(sourceRepositoryProvider, out primarySources, out secondarySources);
if(Arguments.Count == 0)
{
throw new InvalidOperationException(NuGetResources.InstallCommandPackageIdMustBeProvided);
}
string packageId = Arguments[0];
NuGetPackageManager packageManager = new NuGetPackageManager(sourceRepositoryProvider, installPath);
ResolutionContext resolutionContext = new ResolutionContext(dependencyBehavior: DependencyBehavior, includePrelease: Prerelease);
FolderNuGetProject nugetProject = new FolderNuGetProject(installPath);
nugetProject.PackageSaveMode = EffectivePackageSaveMode;
if (Version == null)
{
await packageManager.InstallPackageAsync(nugetProject, packageId, resolutionContext, new Common.Console(),
primarySources, secondarySources, CancellationToken.None);
}
else
{
await packageManager.InstallPackageAsync(nugetProject, new PackageIdentity(packageId, new NuGetVersion(Version)), resolutionContext,
new Common.Console(), primarySources, secondarySources, CancellationToken.None);
}
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
if (IsDataReader(context))
{
var dataReader = (IDataReader)context.SourceValue;
var destinationElementType = TypeHelper.GetElementType(context.DestinationType);
var buildFrom = CreateBuilder(destinationElementType, dataReader);
var results = ObjectCreator.CreateList(destinationElementType);
while (dataReader.Read())
{
results.Add(buildFrom(dataReader));
}
return results;
}
if (IsDataRecord(context))
{
var dataRecord = context.SourceValue as IDataRecord;
var buildFrom = CreateBuilder(context.DestinationType, dataRecord);
var result = buildFrom(dataRecord);
MapPropertyValues(context, mapper, result);
return result;
}
return null;
}
public static AbstractType Demangle(string mangledString, ResolutionContext ctxt, out ITypeDeclaration qualifier, out bool isCFunction)
{
if(string.IsNullOrEmpty(mangledString))
throw new ArgumentException("input string must not be null or empty!");
if (!mangledString.StartsWith("_D"))
{
isCFunction = true;
if (mangledString.StartsWith ("__D"))
mangledString = mangledString.Substring (1);
// C Functions
else if (mangledString.StartsWith ("_")) {
qualifier = new IdentifierDeclaration (mangledString.Substring (1));
return null;
}
}
//TODO: What about C functions that start with 'D'?
isCFunction = false;
var dmng = new Demangler(mangledString) { ctxt = ctxt };
return dmng.MangledName(out qualifier);
}
public static Dictionary<int, Dictionary<ISyntaxRegion, byte>> Scan(DModule ast, ResolutionContext ctxt)
{
if (ast == null)
return new Dictionary<int, Dictionary<ISyntaxRegion,byte>>();
var typeRefFinder = new TypeReferenceFinder(ctxt);
ContextFrame backupFrame = null;
if(ctxt.ScopedBlock == ast)
backupFrame = ctxt.Pop ();
/*
if (ctxt.CurrentContext == null)
{
ctxt.Push(backupFrame);
backupFrame = null;
}*/
//typeRefFinder.ast = ast;
// Enum all identifiers
ast.Accept (typeRefFinder);
if (backupFrame != null)
ctxt.Push (backupFrame);
// Crawl through all remaining expressions by evaluating their types and check if they're actual type references.
/*typeRefFinder.queueCount = typeRefFinder.q.Count;
typeRefFinder.ResolveAllIdentifiers();
*/
return typeRefFinder.Matches;
}
public static void EnumChildren(ICompletionDataGenerator cdgen,ResolutionContext ctxt, IBlockNode block, bool isVarInstance,
MemberFilter vis = MemberFilter.Methods | MemberFilter.Types | MemberFilter.Variables | MemberFilter.Enums, bool publicImports = false)
{
var scan = new MemberCompletionEnumeration(ctxt, cdgen) { isVarInst = isVarInstance };
scan.ScanBlock(block, CodeLocation.Empty, vis, publicImports);
}
public static void EnumChildren(ICompletionDataGenerator cdgen,ResolutionContext ctxt, UserDefinedType udt, bool isVarInstance,
MemberFilter vis = MemberFilter.Methods | MemberFilter.Types | MemberFilter.Variables | MemberFilter.Enums)
{
var scan = new MemberCompletionEnumeration(ctxt, cdgen) { isVarInst = isVarInstance };
scan.DeepScanClass(udt, vis);
}
private ResolutionResult(object value, ResolutionContext context)
{
Value = value;
Context = context;
Type = ResolveType(value, typeof (object));
MemberType = Type;
}
public bool IsMatch(ResolutionContext context)
{
return context.DestinationType.IsAssignableFrom(context.SourceType)
&& context.DestinationType.IsArray
&& context.SourceType.IsArray
&& !ElementsExplicitlyMapped(context);
}
private static bool EnumToEnumMapping(ResolutionContext context)
{
// Enum to enum mapping
var sourceEnumType = TypeHelper.GetEnumerationType(context.SourceType);
var destEnumType = TypeHelper.GetEnumerationType(context.DestinationType);
return sourceEnumType != null && destEnumType != null;
}
private ResolutionResult(object value, ResolutionContext context, Type memberType)
{
Value = value;
Context = context;
Type = ResolveType(value, memberType);
MemberType = memberType;
}
public bool IsMatch(ResolutionContext context)
{
return IsPrimitiveArrayType(context.DestinationType) &&
IsPrimitiveArrayType(context.SourceType) &&
(TypeHelper.GetElementType(context.DestinationType)
.Equals(TypeHelper.GetElementType(context.SourceType)));
}
public object Convert(Type enumSourceType, Type enumDestinationType, ResolutionContext context)
{
Type underlyingSourceType = Enum.GetUnderlyingType(enumSourceType);
var underlyingSourceValue = System.Convert.ChangeType(context.SourceValue, underlyingSourceType);
return Enum.ToObject(context.DestinationType, underlyingSourceValue);
}
public ContextFrame(ResolutionContext ctxt, IBlockNode b, IStatement stmt = null)
{
this.ctxt = ctxt;
declarationCondititons = new ConditionalCompilation.ConditionSet(ctxt.CompilationEnvironment);
Set(b,stmt);
}
UFCSResolver(ResolutionContext ctxt, ISemantic firstArg, int nameHash = 0, ISyntaxRegion sr = null)
: base(ctxt)
{
this.firstArgument = firstArg;
this.nameFilterHash = nameHash;
this.sr = sr;
}
public bool IsMatch(ResolutionContext context)
{
if (context == null) throw new ArgumentNullException("context");
TypeConverter typeConverter = GetTypeConverter(context);
return typeConverter.CanConvertTo(context.DestinationType);
}
/// <summary>
/// </summary>
/// <param name="ast">The syntax tree to scan</param>
/// <param name="symbol">Might not be a child symbol of ast</param>
/// <param name="ctxt">The context required to search for symbols</param>
/// <returns></returns>
public static IEnumerable<ISyntaxRegion> Scan(DModule ast, INode symbol, ResolutionContext ctxt, bool includeDefinition = true)
{
if (ast == null || symbol == null || ctxt == null)
return null;
var f = new ReferencesFinder(symbol, ast, ctxt);
using(ctxt.Push(ast))
ast.Accept (f);
var nodeRoot = symbol.NodeRoot as DModule;
if (includeDefinition && nodeRoot != null && nodeRoot.FileName == ast.FileName)
{
var dc = symbol.Parent as DClassLike;
if (dc != null && dc.ClassType == D_Parser.Parser.DTokens.Template &&
dc.NameHash == symbol.NameHash)
{
f.l.Insert(0, new IdentifierDeclaration(dc.NameHash)
{
Location = dc.NameLocation,
EndLocation = new CodeLocation(dc.NameLocation.Column + dc.Name.Length, dc.NameLocation.Line)
});
}
f.l.Insert(0, new IdentifierDeclaration(symbol.NameHash)
{
Location = symbol.NameLocation,
EndLocation = new CodeLocation(symbol.NameLocation.Column + symbol.Name.Length, symbol.NameLocation.Line)
});
}
return f.l;
}
public object ResolveValue(ResolutionContext context, IMappingEngineRunner mappingEngine)
{
var ctorArgs = new List<object>();
foreach (var map in CtorParams)
{
var result = map.ResolveValue(context);
var sourceType = result.Type;
var destinationType = map.Parameter.ParameterType;
var typeMap = mappingEngine.ConfigurationProvider.ResolveTypeMap(result, destinationType);
Type targetSourceType = typeMap != null ? typeMap.SourceType : sourceType;
var newContext = context.CreateTypeContext(typeMap, result.Value, null, targetSourceType,
destinationType);
if (typeMap == null && map.Parameter.IsOptional)
{
object value = map.Parameter.DefaultValue;
ctorArgs.Add(value);
}
else
{
var value = mappingEngine.Map(newContext);
ctorArgs.Add(value);
}
}
return _runtimeCtor.Value(ctorArgs.ToArray());
}
/// <summary>
/// http://dlang.org/operatoroverloading.html#Dispatch
/// Check for the existence of an opDispatch overload.
/// Important: Because static opDispatches are allowed as well, do check whether we can access non-static overloads from non-instance expressions or such
/// </summary>
public static IEnumerable<AbstractType> TryResolveFurtherIdViaOpDispatch (ResolutionContext ctxt, int nextIdentifierHash, UserDefinedType b, ISyntaxRegion typeBase = null)
{
// The usual SO prevention
if (nextIdentifierHash == opDispatchId || b == null)
yield break;
AbstractType[] overloads;
var opt = ctxt.CurrentContext.ContextDependentOptions;
// Look for opDispatch-Members inside b's Definition
using (ctxt.Push(b))
{
ctxt.CurrentContext.ContextDependentOptions = opt; // Mainly required for not resolving opDispatch's return type, as this will be performed later on in higher levels
overloads = TypeDeclarationResolver.ResolveFurtherTypeIdentifier(opDispatchId, b, ctxt, typeBase, false);
}
if (overloads == null || overloads.Length < 0)
yield break;
var av = new ArrayValue (Evaluation.GetStringType(ctxt), Strings.TryGet(nextIdentifierHash));
foreach (DSymbol o in overloads) {
var dn = o.Definition;
if (dn.TemplateParameters != null && dn.TemplateParameters.Length > 0 &&
dn.TemplateParameters[0] is TemplateValueParameter)
{
//TODO: Test parameter types for being a string value
o.SetDeducedTypes(new[]{ new TemplateParameterSymbol(dn.TemplateParameters[0], av) });
yield return o;
}
}
}
/// <summary>
/// Activates an instance with given arguments.
/// </summary>
/// <param name="resolutionContext">The container.</param>
/// <returns>The activated instance.</returns>
public object ActivateInstance(ResolutionContext resolutionContext)
{
var runtimeArguments = resolutionContext.RuntimeArguments;
if (this._container == null)
{
this._container = resolutionContext.Container;
}
int countOfRuntimeArguments = runtimeArguments.CountOfAllArguments;
if (this._cachedConstructor == null || countOfRuntimeArguments > 0)
{
var constructors = _implementationType.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
_cachedConstructor = this._constructorSelector.SelectConstructor(constructors, resolutionContext);
}
if (this._cachedArguments == null || countOfRuntimeArguments > 0 || GetAnyDependencyParameter(resolutionContext))
{
this._cachedArguments = this._argumentCollector.CollectArguments(
this._container.Resolve,
this._cachedConstructor.GetParameters(),
resolutionContext);
}
if (this._cachedArguments.Length != this._cachedConstructor.GetParameters().Length)
{
throw new ResolutionFailedException(
Resources.NoSuitableConstructorFoundFormat.FormatWith(_implementationType));
}
return this._cachedConstructor.Invoke(this._cachedArguments);
}
/// <summary>
/// Activates an instance with given arguments.
/// </summary>
/// <param name="resolutionContext">The container.</param>
/// <returns>The activated instance.</returns>
public object ActivateInstance(ResolutionContext resolutionContext)
{
if (this._container == null)
{
this._container = resolutionContext.Container;
}
var constructors = _implementationType.GetConstructors(BindingFlags.Public | BindingFlags.Instance);
var finalConstructor = this._constructorSelector.SelectConstructor(constructors, resolutionContext);
object[] finalArguments = this._argumentCollector.CollectArguments(
this._container.Resolve,
finalConstructor.GetParameters(),
resolutionContext);
if (finalArguments != null && finalArguments.Length != finalConstructor.GetParameters().Length)
{
throw new ResolutionFailedException
(Resources.NoSuitableConstructorFoundFormat.FormatWith(_implementationType),
this._implementationType);
}
return finalConstructor.Invoke(finalArguments);
}
public bool IsMatch(ResolutionContext context)
{
return typeof (LambdaExpression).IsAssignableFrom(context.SourceType)
&& context.SourceType != typeof (LambdaExpression)
&& typeof (LambdaExpression).IsAssignableFrom(context.DestinationType)
&& context.DestinationType != typeof (LambdaExpression);
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
var sourceDelegateType = context.SourceType.GetGenericArguments()[0];
var destDelegateType = context.DestinationType.GetGenericArguments()[0];
var expression = (LambdaExpression) context.SourceValue;
if (sourceDelegateType.GetGenericTypeDefinition() != destDelegateType.GetGenericTypeDefinition())
throw new AutoMapperMappingException("Source and destination expressions must be of the same type.");
var parameters = expression.Parameters.ToArray();
var body = expression.Body;
for (int i = 0; i < expression.Parameters.Count; i++)
{
var sourceParamType = sourceDelegateType.GetGenericArguments()[i];
var destParamType = destDelegateType.GetGenericArguments()[i];
if (sourceParamType == destParamType)
continue;
var typeMap = mapper.ConfigurationProvider.ResolveTypeMap(destParamType, sourceParamType);
if (typeMap == null)
throw new AutoMapperMappingException(
$"Could not find type map from destination type {destParamType} to source type {sourceParamType}. Use CreateMap to create a map from the source to destination types.");
var oldParam = expression.Parameters[i];
var newParam = Expression.Parameter(typeMap.SourceType, oldParam.Name);
parameters[i] = newParam;
var visitor = new MappingVisitor(typeMap, oldParam, newParam);
body = visitor.Visit(body);
}
return Expression.Lambda(body, parameters);
}
public static ArrayType GetStringType(ResolutionContext ctxt, LiteralSubformat fmt = LiteralSubformat.Utf8)
{
ArrayType _t = null;
if (ctxt != null && ctxt.ScopedBlock != null)
{
var obj = ctxt.ParseCache.LookupModuleName(ctxt.ScopedBlock.NodeRoot as DModule, "object").FirstOrDefault();
if (obj != null)
{
string strType = fmt == LiteralSubformat.Utf32 ? "dstring" :
fmt == LiteralSubformat.Utf16 ? "wstring" :
"string";
var strNode = obj[strType];
if (strNode != null)
foreach (var n in strNode) {
_t = TypeDeclarationResolver.HandleNodeMatch(n, ctxt) as ArrayType;
if (_t != null)
break;
}
}
}
if (_t == null)
{
var ch = fmt == LiteralSubformat.Utf32 ? DTokens.Dchar :
fmt == LiteralSubformat.Utf16 ? DTokens.Wchar : DTokens.Char;
_t = new ArrayType(new PrimitiveType(ch, DTokens.Immutable));
}
return _t;
}
static void GetDoneVersionDebugSpecs(ConditionSet cs, MutableConditionFlagSet l, DBlockNode m, ResolutionContext ctxt)
{
if (m.StaticStatements == null || m.StaticStatements.Count == 0)
return;
foreach(var ss in m.StaticStatements)
{
if(ss is VersionSpecification)
{
var vs = (VersionSpecification)ss;
if(!_checkForMatchinSpecConditions(m,cs,ss,ctxt))
continue;
if(vs.SpecifiedId==null)
l.AddVersionCondition(vs.SpecifiedNumber);
else
l.AddVersionCondition(vs.SpecifiedId);
}
else if(ss is DebugSpecification)
{
var ds = (DebugSpecification)ss;
if(!_checkForMatchinSpecConditions(m,cs,ss, ctxt))
continue;
if (ds.SpecifiedId == null)
l.AddDebugCondition(ds.SpecifiedDebugLevel);
else
l.AddDebugCondition(ds.SpecifiedId);
}
}
}
Evaluation(AbstractSymbolValueProvider vp) {
this.ValueProvider = vp;
if(vp!=null)
vp.ev = this;
this.eval = true;
this.ctxt = vp.ResolutionContext;
}
private ResolutionResult(object value, ResolutionContext context, Type memberType)
{
_value = value;
_context = context;
_type = ResolveType(value, memberType);
_memberType = memberType;
}
private ResolutionResult(object value, ResolutionContext context)
{
_value = value;
_context = context;
_type = ResolveType(value, typeof(object));
_memberType = _type;
}
public bool IsMatch(ResolutionContext context)
{
if (context == null) throw new ArgumentNullException("context");
bool toEnum = false;
return EnumToStringMapping(context, ref toEnum) || EnumToEnumMapping(context) || EnumToUnderlyingTypeMapping(context, ref toEnum);
}
/// <summary>
/// Install package by Identity
/// </summary>
/// <param name="project"></param>
/// <param name="identity"></param>
/// <param name="resolutionContext"></param>
/// <param name="projectContext"></param>
/// <param name="isPreview"></param>
/// <param name="isForce"></param>
/// <param name="uninstallContext"></param>
/// <returns></returns>
protected async Task InstallPackageByIdentityAsync(NuGetProject project, PackageIdentity identity, ResolutionContext resolutionContext, INuGetProjectContext projectContext, bool isPreview, bool isForce = false, UninstallationContext uninstallContext = null)
{
List<NuGetProjectAction> actions = new List<NuGetProjectAction>();
// For Install-Package -Force
if (isForce)
{
PackageReference installedReference = project.GetInstalledPackagesAsync(CancellationToken.None).Result.Where(p =>
StringComparer.OrdinalIgnoreCase.Equals(identity.Id, p.PackageIdentity.Id)).FirstOrDefault();
if (installedReference != null)
{
actions.AddRange(await PackageManager.PreviewUninstallPackageAsync(project, installedReference.PackageIdentity, uninstallContext, projectContext, CancellationToken.None));
}
NuGetProjectAction installAction = NuGetProjectAction.CreateInstallProjectAction(identity, ActiveSourceRepository);
actions.Add(installAction);
}
else
{
actions.AddRange(await PackageManager.PreviewInstallPackageAsync(project, identity, resolutionContext, projectContext, ActiveSourceRepository, null, CancellationToken.None));
}
if (isPreview)
{
PreviewNuGetPackageActions(actions);
}
else
{
await PackageManager.ExecuteNuGetProjectActionsAsync(project, actions, this, CancellationToken.None);
}
}
public static IEnumerable<TemplateIntermediateType> SearchForClassDerivatives(TemplateIntermediateType t, ResolutionContext ctxt)
{
if (!(t is ClassType || t is InterfaceType))
throw new ArgumentException ("t is expected to be a class or an interface, not " + (t != null ? t.ToString () : "null"));
var f = new ClassInterfaceDerivativeFinder (ctxt);
f.typeNodeToFind = t.Definition;
var bt = t;
while (bt != null) {
f.alreadyResolvedClasses.Add (bt.Definition);
bt = DResolver.StripMemberSymbols (bt.Base) as TemplateIntermediateType;
}
var filter = MemberFilter.Classes;
if (t is InterfaceType) // -> Only interfaces can inherit interfaces. Interfaces cannot be subclasses of classes.
{
filter |= MemberFilter.Interfaces;
f.isInterface = true;
}
f.IterateThroughScopeLayers (t.Definition.Location, filter);
return f.results; // return them.
}
public bool Convert(string sourceMember, ResolutionContext context)
{
return(sourceMember == null);
}
public ManagementEvent Convert(ContentfulEvent source, ManagementEvent destination, ResolutionContext context)
{
destination.Alerts = new Dictionary <string, List <ManagementAlert> > {
{ "en-GB", source.Alerts.Select(o => context.Mapper.Map <ContentfulAlert, ManagementAlert>(o)).ToList() }
};
destination.BookingInformation = new Dictionary <string, string> {
{ "en-GB", source.BookingInformation }
};
destination.Categories = new Dictionary <string, List <string> > {
{ "en-GB", source.Categories }
};
destination.Description = new Dictionary <string, string> {
{ "en-GB", source.Description }
};
destination.Documents = new Dictionary <string, List <LinkReference> > {
{ "en-GB", source.Documents.Select(o => context.Mapper.Map <Asset, LinkReference>(o)).ToList() }
};
destination.EndTime = new Dictionary <string, string> {
{ "en-GB", source.EndTime }
};
destination.EventCategories = new Dictionary <string, List <ManagementEventCategory> >()
{
{
"en-GB",
source.EventCategories.Select(o => context.Mapper.Map <ContentfulEventCategory, ManagementEventCategory>(o)).ToList()
}
};
destination.EventDate = new Dictionary <string, DateTime> {
{ "en-GB", source.EventDate }
};
destination.Featured = new Dictionary <string, bool> {
{ "en-GB", source.Featured }
};
destination.Fee = new Dictionary <string, string> {
{ "en-GB", source.Fee }
};
destination.Free = new Dictionary <string, bool?> {
{ "en-GB", source.Free }
};
if (source.Frequency != EventFrequency.None)
{
destination.Frequency = new Dictionary <string, EventFrequency> {
{ "en-GB", source.Frequency }
};
destination.Occurences = new Dictionary <string, int> {
{ "en-GB", source.Occurences }
};
}
destination.Group = new Dictionary <string, ManagementReference> {
{ "en-GB", new ManagementReference {
Sys = context.Mapper.Map <SystemProperties, ManagementSystemProperties>(source.Group.Sys)
} }
};
destination.Image = string.IsNullOrWhiteSpace(source.Image.SystemProperties.Id) ? null : new Dictionary <string, LinkReference> {
{ "en-GB", new LinkReference()
{
Sys = new ManagementAsset()
{
Id = source.Image.SystemProperties.Id
}
} }
};
destination.Location = new Dictionary <string, string> {
{ "en-GB", source.Location }
};
destination.MapPosition = new Dictionary <string, MapPosition> {
{ "en-GB", source.MapPosition }
};
destination.Paid = new Dictionary <string, bool?> {
{ "en-GB", source.Paid }
};
destination.Slug = new Dictionary <string, string>()
{
{ "en-GB", source.Slug }
};
destination.StartTime = new Dictionary <string, string> {
{ "en-GB", source.StartTime }
};
destination.SubmittedBy = new Dictionary <string, string> {
{ "en-GB", source.SubmittedBy }
};
destination.Tags = new Dictionary <string, List <string> > {
{ "en-GB", source.Tags }
};
destination.Teaser = new Dictionary <string, string> {
{ "en-GB", source.Teaser }
};
destination.Title = new Dictionary <string, string> {
{ "en-GB", source.Title }
};
return(destination);
}
public bool Resolve(UserActivity source, AttendeeDto destination, bool destMember, ResolutionContext context)
{
var currentUser = _context.Users.SingleOrDefaultAsync(x => x.UserName == _userAccessor.GetCurrentUsername()).Result;
if (currentUser.Followings.Any(x => x.TargetId == source.AppUserId))
{
return(true);
}
return(false);
}
public string Resolve(OrderItem source, OrderItemDto destination, string destMember, ResolutionContext context)
{
if (!string.IsNullOrEmpty(source.ItemOrdered.PictureUrl))
{
return(_config["ApiUrl"] + source.ItemOrdered.PictureUrl);
}
return(null);
}
public Dictionary <string, STATE> Convert(List <BindedDocumentVM> sourceMember, ResolutionContext context)
{
Dictionary <string, STATE> result = new Dictionary <string, STATE>();
foreach (BindedDocumentVM p in sourceMember)
{
result.Add(p.Type, (STATE)p.State);
}
return(result);
}
public List <BindedDocumentVM> Convert(Dictionary <string, STATE> sourceMember, ResolutionContext context)
{
List <BindedDocumentVM> result = new List <BindedDocumentVM>();
foreach (KeyValuePair <string, STATE> p in sourceMember)
{
result.Add(new BindedDocumentVM {
State = (STATEVM)p.Value, Type = p.Key
});
}
return(result);
}
/// <summary>
/// Maps the specified source.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="destination">The destination.</param>
/// <param name="context">The context.</param>
/// <returns></returns>
public override string Map(LinkDetails source, string destination, ResolutionContext context)
{
return(source?.Url ?? source?.Script);
}
public ManagementGroup Convert(ContentfulGroup source, ManagementGroup destination, ResolutionContext context)
{
if (destination == null)
{
destination = new ManagementGroup();
}
destination.AdditionalInformation = new Dictionary <string, string> {
{ "en-GB", source.AdditionalInformation }
};
destination.MapPosition = new Dictionary <string, MapPosition> {
{ "en-GB", source.MapPosition }
};
destination.Address = new Dictionary <string, string> {
{ "en-GB", source.Address }
};
destination.Description = new Dictionary <string, string> {
{ "en-GB", source.Description }
};
destination.Email = new Dictionary <string, string> {
{ "en-GB", source.Email }
};
destination.Facebook = new Dictionary <string, string> {
{ "en-GB", source.Facebook }
};
destination.GroupAdministrators = new Dictionary <string, GroupAdministrators> {
{ "en-GB", source.GroupAdministrators }
};
destination.Image = string.IsNullOrWhiteSpace(source.Image.SystemProperties.Id) ? null : new Dictionary <string, LinkReference> {
{ "en-GB", new LinkReference()
{
Sys = new ManagementAsset()
{
Id = source.Image.SystemProperties.Id
}
} }
};
destination.Name = new Dictionary <string, string> {
{ "en-GB", source.Name }
};
destination.PhoneNumber = new Dictionary <string, string> {
{ "en-GB", source.PhoneNumber }
};
destination.Slug = new Dictionary <string, string> {
{ "en-GB", source.Slug }
};
destination.Twitter = new Dictionary <string, string> {
{ "en-GB", source.Twitter }
};
destination.Volunteering = new Dictionary <string, bool> {
{ "en-GB", source.Volunteering }
};
destination.Donations = new Dictionary <string, bool> {
{ "en-GB", source.Donations }
};
destination.Website = new Dictionary <string, string> {
{ "en-GB", source.Website }
};
destination.DateHiddenFrom = new Dictionary <string, string> {
{ "en-GB", source.DateHiddenFrom != null?source.DateHiddenFrom.Value.ToString("yyyy-MM-ddTHH:mm:ssK") : DateTime.MaxValue.ToString("yyyy-MM-ddTHH:mm:ssK") }
};
destination.DateHiddenTo = new Dictionary <string, string> {
{ "en-GB", source.DateHiddenTo != null?source.DateHiddenTo.Value.ToString("yyyy-MM-ddTHH:mm:ssK") : DateTime.MaxValue.ToString("yyyy-MM-ddTHH:mm:ssK") }
};
destination.Cost = new Dictionary <string, List <string> >()
{
{
"en-GB",
source.Cost?.Select(o => o).ToList()
}
};
destination.CostText = new Dictionary <string, string> {
{ "en-GB", source.CostText }
};
destination.AbilityLevel = new Dictionary <string, string> {
{ "en-GB", source.AbilityLevel }
};
destination.CategoriesReference = new Dictionary <string, List <ManagementGroupCategory> >()
{
{
"en-GB",
source.CategoriesReference.Select(o => context.Mapper.Map <ContentfulGroupCategory, ManagementGroupCategory>(o)).ToList()
}
};
destination.VolunteeringText = new Dictionary <string, string> {
{ "en-GB", source.VolunteeringText }
};
if (destination.Organisation != null)
{
destination.Organisation = new Dictionary <string, ManagementReference>()
{
{ "en-GB", new ManagementReference {
Sys = context.Mapper.Map <SystemProperties, ManagementSystemProperties>(source.Organisation.Sys)
} }
};
}
destination.SubCategories = new Dictionary <string, List <ManagementReference> >()
{
{
"en-GB",
source.SubCategories.Select(sc => new ManagementReference {
Sys = context.Mapper.Map <SystemProperties, ManagementSystemProperties>(sc.Sys)
}).ToList()
}
};
destination.AgeRange = new Dictionary <string, List <string> > {
{ "en-GB", source.AgeRange }
};
destination.SuitableFor = new Dictionary <string, List <string> > {
{ "en-GB", source.SuitableFor }
};
destination.DonationsText = new Dictionary <string, string> {
{ "en-GB", source.DonationsText }
};
destination.DonationsUrl = new Dictionary <string, string> {
{ "en-GB", source.DonationsUrl }
};
destination.GroupBranding = new Dictionary <string, List <ManagementReference> >
{
{
"en-GB",
source.GroupBranding.Select(sc => new ManagementReference {
Sys = context.Mapper.Map <SystemProperties, ManagementSystemProperties>(sc.Sys)
}).ToList()
}
};
return(destination);
}
public string Resolve(BlogEntity source, BlogToReturnDto destination, string destMember, ResolutionContext context)
{
if (!string.IsNullOrEmpty(source.PictureUrl))
{
return(_configuration["ApiUrl"] + source.PictureUrl);
}
return(null);
}
public BetDto Convert(Tuple <Player, Bet, string> source, BetDto destination, ResolutionContext context)
{
return(new BetDto
{
Username = source.Item1.Username,
UserId = source.Item1.Id,
Bet = source.Item2?.Amount ?? 0,
IsDivided = source.Item2?.IsSplitted ?? false,
IsDouble = source.Item2?.IsDouble ?? false
});
}
public int Resolve(object source, object destination, int destinationMember, ResolutionContext context)
{
return(source != null ? (int)source : 0);
}
public string Resolve(object source, object destination, string destinationMember, ResolutionContext context)
{
return((bool)source ? "Có" : "Không");
}
public static void HandleOptLinkOutput(AbstractDProject Project, BuildResult br, string linkerOutput)
{
var ctxt = ResolutionContext.Create(DResolverWrapper.CreateParseCacheView(Project), null, null);
ctxt.ContextIndependentOptions =
ResolutionOptions.IgnoreAllProtectionAttributes |
ResolutionOptions.DontResolveBaseTypes |
ResolutionOptions.DontResolveBaseClasses |
ResolutionOptions.DontResolveAliases;
foreach (Match match in optlinkRegex.Matches(linkerOutput))
{
var error = new BuildError();
// Get associated D source file
if (match.Groups["obj"].Success)
{
var obj = Project.GetAbsoluteChildPath(new FilePath(match.Groups["obj"].Value)).ChangeExtension(".d");
foreach (var pf in Project.Files)
{
if (pf.FilePath == obj)
{
error.FileName = pf.FilePath;
break;
}
}
}
var msg = match.Groups["message"].Value;
var symUndefMatch = symbolUndefRegex.Match(msg);
if (symUndefMatch.Success && symUndefMatch.Groups["mangle"].Success)
{
var mangledSymbol = symUndefMatch.Groups["mangle"].Value;
ITypeDeclaration qualifier;
try
{
var resSym = Demangler.DemangleAndResolve(mangledSymbol, ctxt, out qualifier);
if (resSym is DSymbol)
{
var ds = resSym as DSymbol;
var ast = ds.Definition.NodeRoot as DModule;
if (ast != null)
{
error.FileName = ast.FileName;
}
error.Line = ds.Definition.Location.Line;
error.Column = ds.Definition.Location.Column;
msg = ds.Definition.ToString(false, true);
}
else
{
msg = qualifier.ToString();
}
}
catch (Exception ex)
{
msg = "<log analysis error> " + ex.Message;
}
error.ErrorText = msg + " could not be resolved - library reference missing?";
}
else
{
error.ErrorText = "Linker error " + match.Groups["code"].Value + " - " + msg;
}
br.Append(error);
}
}
public string Resolve(object source, object destination, string destinationMember, ResolutionContext context)
{
return(source != null ? context.Options.Items[destinationValue].ToString() : string.Empty);
}
string IValueResolver <Employee, EmployeeView, string> .Resolve(Employee source, EmployeeView destination, string destMember, ResolutionContext context)
{
if (source.User != null)
{
var user = Resolve(source).Result;
return(user);
}
return(null);
}
public static TDestination Map <TSource, TSourceKey, TSourceValue, TDestination, TDestinationKey, TDestinationValue>(TSource source, TDestination destination, ResolutionContext context)
where TSource : IDictionary <TSourceKey, TSourceValue>
where TDestination : class, IDictionary <TDestinationKey, TDestinationValue>
{
if (source == null && context.Mapper.ShouldMapSourceCollectionAsNull(context))
{
return(null);
}
TDestination list = destination ?? (
typeof(TDestination).IsInterface()
? new Dictionary <TDestinationKey, TDestinationValue>() as TDestination
: (TDestination)(context.ConfigurationProvider.AllowNullDestinationValues
? ObjectCreator.CreateNonNullValue(typeof(TDestination))
: ObjectCreator.CreateObject(typeof(TDestination))));
list.Clear();
var itemContext = new ResolutionContext(context);
foreach (var keyPair in (IEnumerable <KeyValuePair <TSourceKey, TSourceValue> >)source ?? Enumerable.Empty <KeyValuePair <TSourceKey, TSourceValue> >())
{
list.Add(itemContext.Map(keyPair.Key, default(TDestinationKey)),
itemContext.Map(keyPair.Value, default(TDestinationValue)));
}
return(list);
}
public bool Resolve(Object source, Object destination, bool flag, ResolutionContext context)
{
return(false);
}
public string Resolve(Object source, Object destination, string message, ResolutionContext context)
{
var messageNew = "";
return(messageNew);
}
public string Resolve(Product source, ProductView destination, string destMember, ResolutionContext context)
{
if (source.AvailabilityStatus == null)
{
return("");
}
if (source.AvailabilityStatus == 0)
{
return("");
}
var item = _productStatusAvBusinessLogic.GetById(source.AvailabilityStatus);
return(item.Name);
}
public string Resolve(Product source, ProductView destination, string destMember, ResolutionContext context)
{
if (source.Gender == null)
{
return("");
}
if (source.Gender == 0)
{
return("");
}
var item = _genderBusinessLogic.GetById(source.Gender);
return(item.Name);
}
public string Resolve(EmployeeView source, Employee destination, string destMember, ResolutionContext context)
{
if (source.UserName != null)
{
var user = Resolve(source).Result;
return(user);
}
return(null);
}
public string Resolve(Product source, ProductView destination, string destMember, ResolutionContext context)
{
if (source.ProductType == null)
{
return("");
}
if (source.ProductType == 0)
{
return("");
}
var type = _productTypeBusinessLogic.GetById(source.ProductType);
return(type.Name);
}
public PatientForGet Resolve(Claim source, ClaimForGet destination, PatientForGet member, ResolutionContext context)
{
return(new PatientForGet {
Name = source.BeneficiaryName, Gender = source.PatientGender, Address = source.PatientAddress
});
}
public UserClaim Resolve(QueryUniqueDto source, QueryUnique destination, UserClaim destMember, ResolutionContext context)
{
return(Helper.GetClaimsFromUser(_httpContextAccessor.HttpContext?.User.Identity as ClaimsIdentity));
}
public static async Task <IEnumerable <NuGetProjectAction> > GetInstallProjectActionsAsync(
this NuGetPackageManager packageManager,
NuGetFolderProject nuGetProject,
PackageIdentity packageIdentity,
ResolutionContext resolutionContext,
INuGetProjectContext nuGetProjectContext,
IEnumerable <SourceRepository> primarySourceRepositories,
IEnumerable <SourceRepository> secondarySourceRepositories,
CancellationToken token)
{
if (nuGetProject == null)
{
throw new ArgumentNullException(nameof(nuGetProject));
}
if (packageIdentity == null)
{
throw new ArgumentNullException(nameof(packageIdentity));
}
if (resolutionContext == null)
{
throw new ArgumentNullException(nameof(resolutionContext));
}
if (nuGetProjectContext == null)
{
throw new ArgumentNullException(nameof(nuGetProjectContext));
}
if (primarySourceRepositories == null)
{
throw new ArgumentNullException(nameof(primarySourceRepositories));
}
if (!primarySourceRepositories.Any())
{
throw new ArgumentException(nameof(primarySourceRepositories));
}
if (secondarySourceRepositories == null)
{
throw new ArgumentNullException(nameof(secondarySourceRepositories));
}
if (packageIdentity.Version == null)
{
throw new ArgumentNullException(nameof(packageIdentity));
}
var localSources = new HashSet <SourceRepository>(new SourceRepositoryComparer());
localSources.Add(packageManager.PackagesFolderSourceRepository);
localSources.AddRange(packageManager.GlobalPackageFolderRepositories);
if (resolutionContext.DependencyBehavior == DependencyBehavior.Ignore)
{
var logger = new ProjectContextLogger(nuGetProjectContext);
// First, check only local sources.
var sourceRepository = await GetSourceRepositoryAsync(packageIdentity, localSources, resolutionContext.SourceCacheContext, logger, token);
if (sourceRepository == null)
{
// Else, check provided sources. We use only primary sources when we don't care about dependencies.
sourceRepository = await GetSourceRepositoryAsync(packageIdentity, primarySourceRepositories, resolutionContext.SourceCacheContext, logger, token);
}
// If still not found, we just throw an exception.
if (sourceRepository == null)
{
throw new InvalidOperationException($"Unable to find version '{packageIdentity.Version}' of package '{packageIdentity.Id}'.");
}
return(new[] { NuGetProjectAction.CreateInstallProjectAction(packageIdentity, sourceRepository, nuGetProject) });
}
var primarySources = new HashSet <SourceRepository>(new SourceRepositoryComparer());
var allSources = new HashSet <SourceRepository>(new SourceRepositoryComparer());
Tuple <IReadOnlyCollection <PackageIdentity>, IReadOnlyCollection <SourcePackageDependencyInfo> > packageAndDependencies = null;
var allDependenciesResolved = false;
// If target package is already installed, there's a slight chance that all packages are already installed.
if (await PackageExistsInSourceRepository(
packageIdentity,
packageManager.PackagesFolderSourceRepository,
resolutionContext.SourceCacheContext,
new ProjectContextLogger(nuGetProjectContext),
token))
{
primarySources.Add(packageManager.PackagesFolderSourceRepository);
allSources.Add(packageManager.PackagesFolderSourceRepository);
try
{
// Try get all dependencies from local sources only.
packageAndDependencies = await GetPackageAndDependenciesToInstall(
packageManager,
nuGetProject,
packageIdentity,
resolutionContext,
nuGetProjectContext,
primarySources,
allSources,
token);
allDependenciesResolved = true;
}
catch (NuGetResolverConstraintException)
{
// We didn't manage to find all dependencies in the local packages folder.
allDependenciesResolved = false;
}
}
// If we didn't manage to resolve all dependencies from the local sources, check in all sources.
if (!allDependenciesResolved)
{
primarySources.AddRange(localSources);
primarySources.AddRange(primarySourceRepositories);
allSources.AddRange(primarySources);
allSources.AddRange(secondarySourceRepositories);
packageAndDependencies = await GetPackageAndDependenciesToInstall(
packageManager,
nuGetProject,
packageIdentity,
resolutionContext,
nuGetProjectContext,
primarySources,
allSources,
token);
}
// Create the install actions.
return(GetProjectActions(
packageIdentity,
packageAndDependencies.Item1,
packageAndDependencies.Item2,
nuGetProject));
}
public ProductTypeDto Convert(ProductType source, ProductTypeDto destination, ResolutionContext context)
{
if (source.Name == "A")
{
return(new ProdTypeA());
}
if (source.Name == "B")
{
return(new ProdTypeB());
}
throw new ArgumentException();
}
public IDictionary <string, Right> Convert(rightType[] source, IDictionary <string, Right> destination, ResolutionContext context)
{
ICollection <Right> values = mapper.Map <rightType[], ICollection <Right> >(source);
IDictionary <string, Right> rights = new Dictionary <string, Right>();
foreach (Right right in values)
{
rights.Add(right.Type, right);
}
return(rights);
}
public List <string> Resolve(ServiceModel source, ServiceDTO destination, List <string> destMember, ResolutionContext context)
{
var instances = _cache.Get <List <string> >(KakaduConstants.ACTIONAPI_INSTANCES);
if (instances == null || !instances.Any())
{
return(new List <string>());
}
return(instances.Select(instance => ConcatUrl(instance, source.Code)).ToList());
}
public IDictionary <string, ProvisionedZone> Convert(provisionedZoneType[] source, IDictionary <string, ProvisionedZone> destination, ResolutionContext context)
{
ICollection <ProvisionedZone> values = mapper.Map <provisionedZoneType[], ICollection <ProvisionedZone> >(source);
IDictionary <string, ProvisionedZone> provisionedZones = new Dictionary <string, ProvisionedZone>();
foreach (ProvisionedZone provisionedZone in values)
{
provisionedZones.Add(provisionedZone.SifId, provisionedZone);
}
return(provisionedZones);
}
public string Resolve(KnownRouteReplyDTO source, KnownRouteReplyModel destination, string destMember, ResolutionContext context)
{
if (source == null)
{
return(string.Empty);
}
// decompress content if needed
return(string.IsNullOrWhiteSpace(source.ContentEncoding) ? source.ContentBase64 : source.Decompressed());
}