protected void AddParameterInternal(string parameter, object value, bool isOptionParam)
{
bool flag;
object[] cmdletName = new object[2];
cmdletName[0] = parameter;
cmdletName[1] = this.cmdletInfo.CmdletName;
ExceptionHelpers.ThrowArgumentExceptionIf("parameter", this.parameters.ContainsKey(parameter), Resources.ParameterAlreadyAddedToCommand, cmdletName);
string str = "parameter";
if (!isOptionParam)
{
flag = false;
}
else
{
flag = !this.cmdletInfo.IsValidOption(parameter);
}
object[] objArray = new object[2];
objArray[0] = parameter;
objArray[1] = this.cmdletInfo.CmdletName;
ExceptionHelpers.ThrowArgumentExceptionIf(str, flag, Resources.NotValidUrlOption, objArray);
if (this.ValidateParameterForSwitch(parameter, value))
{
this.commonParameterFlag = this.GetCommonParameterSets(parameter);
this.parameters.Add(parameter, value);
return;
}
else
{
return;
}
}
public CollectionResourceTypeSerializer(ResourceType resourceType) : base(resourceType)
{
object[] resourceTypeKind = new object[2];
resourceTypeKind[0] = resourceType.ResourceTypeKind;
resourceTypeKind[1] = ResourceTypeKind.Collection;
ExceptionHelpers.ThrowArgumentExceptionIf("resourceType", resourceType.ResourceTypeKind != ResourceTypeKind.Collection, new ExceptionHelpers.MessageLoader(SerializerBase.GetInvalidArgMessage), resourceTypeKind);
}
private ulong GetCommonParameterSets(string parameter)
{
ulong num = this.cmdletInfo.FindParameterSets(parameter);
object[] cmdletName = new object[2];
cmdletName[0] = parameter;
cmdletName[1] = this.cmdletInfo.CmdletName;
ExceptionHelpers.ThrowArgumentExceptionIf("parameter", num == (long)0, Resources.ParameterNotFoundInCommand, cmdletName);
if (this.parameters.Count > 0)
{
ulong num1 = this.commonParameterFlag & num;
if (num1 != (long)0)
{
num = num1;
}
else
{
object[] objArray = new object[2];
objArray[0] = parameter;
objArray[1] = this.cmdletInfo.CmdletName;
throw new ArgumentException(ExceptionHelpers.GetExceptionMessage(Resources.ParametersAddedFromExclusiveSets, objArray));
}
}
return(num);
}
internal IUpdateInstance GetInstanceFromHandle(object resource)
{
object str;
IUpdateInstance updateInstance = resource as IUpdateInstance;
string str1 = "resource";
bool flag = updateInstance == null;
string invalidUpdateHandle = Resources.InvalidUpdateHandle;
object[] objArray = new object[1];
object[] objArray1 = objArray;
int num = 0;
if (resource != null)
{
str = resource.ToString();
}
else
{
str = string.Empty;
}
objArray1[num] = str;
ExceptionHelpers.ThrowArgumentExceptionIf(str1, flag, invalidUpdateHandle, objArray);
ExceptionHelpers.ThrowArgumentExceptionIf("resource", !this.instances.Contains(updateInstance), Resources.NoLongerValidUpdateHandle, new object[0]);
return(updateInstance);
}
internal PSParameterInfo FindParameterInfo(string parameter)
{
IEnumerable <PSParameterSet> pSParameterSets = this.ParameterSets.FindAll((PSParameterSet item) => item.Parameters.ContainsKey(parameter));
object[] cmdletName = new object[2];
cmdletName[0] = parameter;
cmdletName[1] = this.CmdletName;
ExceptionHelpers.ThrowArgumentExceptionIf("parameter", pSParameterSets.Count <PSParameterSet>() == 0, Resources.ParameterNotFoundInCommand, cmdletName);
PSParameterInfo pSParameterInfo = null;
foreach (PSParameterSet pSParameterSet in pSParameterSets)
{
PSParameterInfo pSParameterInfo1 = pSParameterSet.Parameters[parameter];
if (pSParameterInfo != null)
{
if (!(pSParameterInfo.Type != pSParameterInfo1.Type) && pSParameterInfo.IsSwitch == pSParameterInfo1.IsSwitch)
{
continue;
}
TraceHelper.Current.DebugMessage(string.Concat("Parameter ", parameter, " is found in multiple parameter set and has either different Type or IsSwitch value. So FindParametersInfo returns null"));
pSParameterInfo = null;
break;
}
else
{
pSParameterInfo = pSParameterInfo1;
}
}
return(pSParameterInfo);
}
public PrimitiveTypeSerializer(ResourceType resourceType, ResourceProperty resourceProperty) : base(resourceType)
{
object defaultValue;
object[] resourceTypeKind = new object[2];
resourceTypeKind[0] = resourceType.ResourceTypeKind;
resourceTypeKind[1] = ResourceTypeKind.Primitive;
ExceptionHelpers.ThrowArgumentExceptionIf("resourceType", resourceType.ResourceTypeKind != ResourceTypeKind.Primitive, new ExceptionHelpers.MessageLoader(SerializerBase.GetInvalidArgMessage), resourceTypeKind);
this.defaultValue = null;
if (resourceProperty != null)
{
if ((resourceProperty.Kind & ResourcePropertyKind.Primitive) != ResourcePropertyKind.Primitive || resourceProperty.ResourceType.InstanceType != resourceType.InstanceType)
{
throw new ArgumentException("resourceProperty");
}
else
{
PropertyCustomState customState = resourceProperty.GetCustomState();
PrimitiveTypeSerializer primitiveTypeSerializer = this;
if (customState != null)
{
defaultValue = customState.DefaultValue;
}
else
{
defaultValue = null;
}
primitiveTypeSerializer.defaultValue = defaultValue;
this.name = resourceProperty.Name;
}
}
}
public EntityTypeSerializer(ResourceType resourceType, bool serializeKeyOnly = false) : base(resourceType)
{
object[] resourceTypeKind = new object[2];
resourceTypeKind[0] = resourceType.ResourceTypeKind;
resourceTypeKind[1] = ResourceTypeKind.EntityType;
ExceptionHelpers.ThrowArgumentExceptionIf("resourceType", resourceType.ResourceTypeKind != ResourceTypeKind.EntityType, new ExceptionHelpers.MessageLoader(SerializerBase.GetInvalidArgMessage), resourceTypeKind);
this.serializeKeyOnly = serializeKeyOnly;
this.TestHookEntityMetadata = null;
}
public EntityMetadata GetEntityMetadata(ResourceType resourceType)
{
object[] name = new object[3];
name[0] = resourceType.Name;
name[1] = ResourceTypeKind.EntityType;
name[2] = resourceType.ResourceTypeKind;
ExceptionHelpers.ThrowArgumentExceptionIf("resourceType", resourceType.ResourceTypeKind != ResourceTypeKind.EntityType, Resources.ResourceTypeIsInvalid, name);
return(this.EntityMetadataDictionary[resourceType.FullName]);
}
public object GetResource(IQueryable query, string fullTypeName)
{
object obj;
TraceHelper.Current.MethodCall2("DataServiceUpdateProvider", "GetResource", query.ToString(), fullTypeName);
try
{
DSLinqQueryProvider provider = query.Provider as DSLinqQueryProvider;
ExceptionHelpers.ThrowArgumentExceptionIf("query", provider == null, Resources.QueryDoesNotIncludePswsProvider, new object[0]);
if (!provider.IsFilterOverResourceRoot(query.Expression))
{
ReferredResourceExtractor referredResourceExtractor = new ReferredResourceExtractor();
DSResource current = null;
if (!referredResourceExtractor.Extract(query.Expression, provider.GetInitialQueryable(), provider.GetInitialResourceType(), provider.GetEntityMetadata(provider.GetInitialResourceType())))
{
IEnumerator <DSResource> enumerator = (query.GetEnumerator() as IEnumerable <DSResource>).GetEnumerator();
if (enumerator.MoveNext())
{
current = enumerator.Current;
if (enumerator.MoveNext())
{
throw new ArgumentException("multiple instances");
}
}
else
{
throw new ArgumentException("no instances");
}
}
else
{
current = referredResourceExtractor.ReferredResource;
}
ResourceType resourceType = current.ResourceType;
EntityMetadata entityMetadata = provider.GetEntityMetadata(resourceType);
IUpdateInstance referredEntityInstance = new ReferredEntityInstance(current, this.dataContext.UserContext, resourceType, entityMetadata, this.dataContext.MembershipId);
this.instances.Add(referredEntityInstance);
obj = referredEntityInstance;
}
else
{
ResourceType initialResourceType = provider.GetInitialResourceType();
EntityMetadata entityMetadatum = provider.GetEntityMetadata(initialResourceType);
this.entityInstance = new EntityUpdate(CommandType.Update, this.dataContext.UserContext, initialResourceType, entityMetadatum, query, this.dataContext.MembershipId);
this.instances.Add(this.entityInstance);
obj = this.entityInstance;
}
}
catch (ArgumentException argumentException1)
{
ArgumentException argumentException = argumentException1;
TraceHelper.Current.InvalidUpdateQuery(fullTypeName, query.ToString(), argumentException.GetType().ToString(), argumentException.Message);
obj = null;
}
return(obj);
}
public bool AddFieldParameter(string parameter, object value)
{
ResourceProperty resourceProperty = this.resourceType.KeyProperties.SingleOrDefault <ResourceProperty>((ResourceProperty p) => p.Name == parameter);
object[] objArray = new object[1];
objArray[0] = parameter;
ExceptionHelpers.ThrowArgumentExceptionIf("parameter", resourceProperty == null, Resources.FieldIsNotAKey, objArray);
this.propertyUpdates.Add(parameter, value);
return(true);
}
public static void AddDerivedType(this ResourceType resourceType, ResourceType derivedType)
{
object[] name = new object[1];
name[0] = resourceType.Name;
derivedType.ThrowIfNull("derivedType", Resources.NullPassedAsDerivedType, name);
object[] fullName = new object[2];
fullName[0] = resourceType.FullName;
fullName[1] = derivedType.FullName;
ExceptionHelpers.ThrowArgumentExceptionIf("derivedType", derivedType.BaseType != resourceType, Resources.NotBaseResourceType, fullName);
(resourceType.CustomState as ResourceCustomState).DerivedTypes.Add(derivedType);
}
public ICommand GetCommand(CommandType commandType, UserContext userContext, ResourceType entityType, EntityMetadata entityMetadata, string membershipId)
{
Envelope <PSRunspace, UserContext> envelope = this.runspaceStore.Borrow(userContext, membershipId);
PSEntityMetadata pSEntityMetadatum = entityMetadata as PSEntityMetadata;
object[] assemblyQualifiedName = new object[3];
assemblyQualifiedName[0] = "entityMetadata";
assemblyQualifiedName[1] = entityMetadata.GetType().AssemblyQualifiedName;
assemblyQualifiedName[2] = typeof(PSEntityMetadata).AssemblyQualifiedName;
ExceptionHelpers.ThrowArgumentExceptionIf("entityMetadata", pSEntityMetadatum == null, Resources.InvalidArgClrType, assemblyQualifiedName);
object[] name = new object[2];
name[0] = entityType.Name;
name[1] = commandType.ToString();
ExceptionHelpers.ThrowArgumentExceptionIf("entityMetadata", !pSEntityMetadatum.Cmdlets.ContainsKey(commandType), Resources.EntityDoesNotHaveCommand, name);
return(new PSCommand(envelope, entityType, pSEntityMetadatum.Cmdlets[commandType], commandType));
}
public static DSResource SerializeEntity(object instance, ResourceType resourceType)
{
object[] resourceTypeKind = new object[2];
resourceTypeKind[0] = resourceType.ResourceTypeKind;
resourceTypeKind[1] = ResourceTypeKind.EntityType;
ExceptionHelpers.ThrowArgumentExceptionIf("resourceType", resourceType.ResourceTypeKind != ResourceTypeKind.EntityType, new ExceptionHelpers.MessageLoader(SerializerBase.GetInvalidArgMessage), resourceTypeKind);
DSResource dSResource = SerializerBase.SerializeResourceType(instance, resourceType, 1) as DSResource;
if (dSResource != null)
{
return(dSResource);
}
else
{
throw new InvalidOperationException(Resources.SerializeEntityReturnedNull);
}
}
public object CreateResource(string containerName, string fullTypeName)
{
TraceHelper.Current.MethodCall2("DataServiceUpdateProvider", "AddReferenceToCollection", containerName, fullTypeName);
ResourceType resourceType = null;
if (containerName != null)
{
ResourceSet resourceSet = null;
this.dataContext.UserSchema.ResourceSets.TryGetValue(containerName, out resourceSet);
object[] objArray = new object[1];
objArray[0] = containerName;
ExceptionHelpers.ThrowArgumentExceptionIf("set", resourceSet == null, Resources.MissingResourceSet, objArray);
if (this.entityInstance == null)
{
resourceType = resourceSet.ResourceType;
EntityMetadata item = this.dataContext.UserSchema.EntityMetadataDictionary[resourceSet.ResourceType.FullName];
this.entityInstance = new EntityUpdate(this.dataContext.UserContext, resourceType, item, this.dataContext.MembershipId);
this.instances.Add(this.entityInstance);
return(this.entityInstance);
}
else
{
throw new NotImplementedException(ExceptionHelpers.GetExceptionMessage(Resources.BatchUpdatesNotSupported, new object[0]));
}
}
else
{
this.dataContext.UserSchema.ResourceTypes.TryGetValue(fullTypeName, out resourceType);
if (resourceType != null)
{
object[] objArray1 = new object[1];
objArray1[0] = fullTypeName;
ExceptionHelpers.ThrowArgumentExceptionIf("fullTypeName", resourceType.ResourceTypeKind != ResourceTypeKind.ComplexType, Resources.NotAComplexType, objArray1);
IUpdateInstance complexTypeInstance = new ComplexTypeInstance(resourceType);
this.instances.Add(complexTypeInstance);
return(complexTypeInstance);
}
else
{
TraceHelper.Current.ResourceTypeNotFound(fullTypeName);
object[] objArray2 = new object[1];
objArray2[0] = fullTypeName;
throw new ArgumentException(ExceptionHelpers.GetExceptionMessage(Resources.MissingResourceType, objArray2));
}
}
}
public CustomAuthorizationHandler(string customAuthzAssembly, string customAuthzTypeName, CustomAuthorizationHandler.ICustomContextStore customContextStore)
{
try
{
if (customContextStore != null)
{
this.customContextStore = customContextStore;
}
else
{
this.customContextStore = new CustomAuthorizationHandler.OperationContextBasedContextStore();
}
Type type = TypeLoader.LoadType(customAuthzAssembly, customAuthzTypeName);
if (type != null)
{
this.customAuthorization = type.Assembly.CreateInstance(type.FullName) as CustomAuthorization;
ExceptionHelpers.ThrowArgumentExceptionIf("customAuthzTypeName", this.customAuthorization == null, Resources.CustomAuthorizationPluginCreationFailed, new object[0]);
}
else
{
object[] objArray = new object[2];
objArray[0] = customAuthzTypeName;
objArray[1] = customAuthzAssembly;
throw new ArgumentException(ExceptionHelpers.GetExceptionMessage(Resources.TypeLoadFromAssebmlyFailed, objArray), "customAuthzTypeName");
}
}
catch (Exception exception1)
{
Exception exception = exception1;
TraceHelper.Current.CustomAuthorizationLoadingFailed(customAuthzAssembly, exception.ToTraceMessage("Exception"));
if (!exception.IsSevereException())
{
throw new TypeLoadException(customAuthzTypeName, customAuthzAssembly, Utils.GetBaseBinDirectory(customAuthzAssembly), exception);
}
else
{
throw;
}
}
TraceHelper.Current.CustomAuthorizationLoadedSuccessfully(customAuthzTypeName);
}
internal ScriptBlockAst ValidateAndBuildPipeline(string rawString)
{
Token[] tokenArray = null;
ParseError[] parseErrorArray = null;
bool length;
ScriptBlockAst scriptBlockAst = Parser.ParseInput(rawString, out tokenArray, out parseErrorArray);
string str = "rawString";
if (parseErrorArray == null)
{
length = false;
}
else
{
length = (int)parseErrorArray.Length != 0;
}
object[] objArray = new object[1];
objArray[0] = rawString;
ExceptionHelpers.ThrowArgumentExceptionIf(str, length, Resources.InvalidPipeline, objArray);
return(scriptBlockAst);
}
public EntityUpdate(CommandType commandType, UserContext userContext, ResourceType type, EntityMetadata metadata, IQueryable query, string membershipId)
{
ExceptionHelpers.ThrowArgumentExceptionIf("commandType", commandType != CommandType.Update, Resources.InternalErrorOccurred, new object[0]);
this.query = query;
this.userContext = userContext;
this.membershipId = membershipId;
this.resourceType = type;
this.metadata = metadata;
this.commandType = commandType;
this.propertyUpdates = new SortedDictionary <string, object>();
this.updatedResource = null;
this.resolveResource = null;
CommandArgumentVisitor commandArgumentVisitor = new CommandArgumentVisitor(this);
commandArgumentVisitor.Visit(query.Expression);
if (this.AreAllKeyFieldsSpecified())
{
return;
}
else
{
throw new ArgumentException(ExceptionHelpers.GetExceptionMessage(Resources.KeysMissingInQuery, new object[0]));
}
}
