internal void MapParameters(bool reduceByRef) {
if (reduceByRef) {
_returnArgs = new List<int>();
if (CompilerHelpers.GetReturnType(_method) != typeof(void)) {
_returnArgs.Add(-1);
}
}
BitArray specialParameters = _resolver.MapSpecialParameters(this);
if (_instanceBuilder == null) {
_instanceBuilder = new NullArgBuilder();
}
for (int infoIndex = 0; infoIndex < _parameterInfos.Length; infoIndex++) {
if (!IsSpecialParameter(specialParameters, infoIndex)) {
if (reduceByRef) {
MapParameterReduceByRef(_parameterInfos[infoIndex]);
} else {
MapParameter(_parameterInfos[infoIndex]);
}
}
}
_returnBuilder = MakeReturnBuilder(specialParameters);
}
public void SelectAllItems(ICollectionView availableItemsCollectionView)
{
var itemVM = _returnItemVmFactory.GetViewModelInstance();
itemVM.IsBulkReturn = true;
var confirmation = new ConditionalConfirmation {
Title = "Specify return reason".Localize(), Content = itemVM
};
ReturnItemConfirmRequest.Raise(confirmation, (x) =>
{
if (x.Confirmed)
{
var itemsList = new List <ReturnBuilder.ReturnLineItem>(availableItemsCollectionView.Cast <ReturnBuilder.ReturnLineItem>());
foreach (var obj in itemsList)
{
ReturnBuilder.AddReturnItem(obj, obj.LineItem.Quantity, itemVM.SelectedReason);
}
OnPropertyChanged("ReturnTotal");
OnIsValidChanged();
}
});
}
private ReturnBuilder MakeKeywordReturnBuilder(ReturnBuilder returnBuilder, ParameterInfo[] methodParams, List <ParameterWrapper> parameters)
{
if (_binderType == BinderType.Constructor)
{
List <SymbolId> unusedNames = GetUnusedKeywordParameters(methodParams);
List <MemberInfo> bindableMembers = GetBindableMembers(returnBuilder, unusedNames);
List <int> kwArgIndexs = new List <int>();
if (unusedNames.Count == bindableMembers.Count)
{
foreach (MemberInfo mi in bindableMembers)
{
ParameterWrapper pw = new ParameterWrapper(
_binder,
mi.MemberType == MemberTypes.Property ?
((PropertyInfo)mi).PropertyType :
((FieldInfo)mi).FieldType,
false,
SymbolTable.StringToId(mi.Name));
parameters.Add(pw);
kwArgIndexs.Add(GetKeywordIndex(mi.Name));
}
KeywordConstructorReturnBuilder kwBuilder = new KeywordConstructorReturnBuilder(returnBuilder,
_kwArgs.Length,
kwArgIndexs.ToArray(),
bindableMembers.ToArray());
return(kwBuilder);
}
}
return(returnBuilder);
}
// constructor (for single wizard step)
protected CreateExchangeViewModel(
IOrderEntityFactory entityFactory,
IViewModelsFactory <IOrderAddressViewModel> addressVmFactory,
ReturnBuilder returnBuilder,
IViewModelsFactory <ILineItemAddViewModel> lineItemAddVmFactory,
bool isCreatingExchangeOrderOnly,
IViewModelsFactory <IReturnItemViewModel> returnItemVmFactory,
IRepositoryFactory <IShippingRepository> shippingRepositoryFactory)
: base(returnItemVmFactory, returnBuilder, isCreatingExchangeOrderOnly)
{
_shippingRepositoryFactory = shippingRepositoryFactory;
_lineItemAddVmFactory = lineItemAddVmFactory;
LineItemAddVM = lineItemAddVmFactory.GetViewModelInstance();
if (this is IExchangeOrderStepViewModel)
{
_entityFactory = entityFactory;
_addressVmFactory = addressVmFactory;
// workaround for null pointer exception
returnBuilder.WithExchangeShippingAddress(new OrderAddress()
{
OrderAddressId = "fake address"
});
LineItemAddVM.SelectedItemsToAdd.CollectionChanged += SelectedItemsToAdd_CollectionChanged;
ShippingAddress = AvailableShippingAddresses.FirstOrDefault();
ShippingMethod = AvailableShippingMethods.FirstOrDefault();
}
}
public void UnSelectItem(object selectedObj)
{
var returnItem = (RmaReturnItem)selectedObj;
ReturnBuilder.RemoveReturnItem(returnItem, returnItem.RmaLineItems[0].ReturnQuantity);
OnPropertyChanged("ReturnTotal");
OnIsValidChanged();
}
public RmaRequest GetRmaRequest()
{
var result = ReturnBuilder.CompleteReturnBuild();
//if (!_isCreatingExchangeOrderOnly)
// result.GenerateRmaRequestId();
return(result);
}
protected CreateRmaRequestViewModel(IViewModelsFactory<IReturnItemViewModel> returnItemVmFactory, ReturnBuilder returnBuilder, bool isCreatingExchangeOrderOnly = false)
{
_returnItemVmFactory = returnItemVmFactory;
ReturnBuilder = returnBuilder;
_isCreatingExchangeOrderOnly = isCreatingExchangeOrderOnly;
ReturnItemConfirmRequest = new InteractionRequest<Confirmation>();
}
protected CreateRmaRequestViewModel(IViewModelsFactory <IReturnItemViewModel> returnItemVmFactory, ReturnBuilder returnBuilder, bool isCreatingExchangeOrderOnly = false)
{
_returnItemVmFactory = returnItemVmFactory;
ReturnBuilder = returnBuilder;
_isCreatingExchangeOrderOnly = isCreatingExchangeOrderOnly;
ReturnItemConfirmRequest = new InteractionRequest <Confirmation>();
}
public void UnSelectAllItems(IList currentListItems)
{
foreach (var returnItem in ReturnBuilder.RmaReturnItems.ToArray())
{
ReturnBuilder.RemoveReturnItem(returnItem, returnItem.RmaLineItems[0].ReturnQuantity);
}
OnPropertyChanged("ReturnTotal");
OnIsValidChanged();
}
public RmaRequestRefundStepViewModel(ReturnBuilder returnBuilder, IPaymentMethodRepository repository, StoreClient client)
: base(null, returnBuilder)
{
var paymentMethodNames = ReturnBuilder.CurrentOrder.OrderForms[0].Payments.Select(x => x.PaymentMethodName).Distinct();
PaymentMethods = paymentMethodNames.ToArray();
NewPaymentSource = CreateRefundViewModel.GetNewPaymentModel(ReturnBuilder.CurrentOrder.InnerItem, repository, client);
}
internal MethodTarget(MethodBinder binder, MethodBase method, int parameterCount, ArgBuilder instanceBuilder, IList<ArgBuilder> argBuilders, ReturnBuilder returnBuilder) {
this._binder = binder;
this._method = method;
this._parameterCount = parameterCount;
this._instanceBuilder = instanceBuilder;
this._argBuilders = argBuilders;
this._returnBuilder = returnBuilder;
//argBuilders.TrimExcess();
}
// main public constructor. calls CreateWizardSteps()
public CreateExchangeViewModel(Foundation.Orders.Model.Order innerOrder,
RmaRequest rmaRequest, IRepositoryFactory <IShippingRepository> shippingRepositoryFactory,
IViewModelsFactory <IRmaRequestReturnItemsStepViewModel> returnItemsVmFactory,
IViewModelsFactory <IRmaRequestRefundStepViewModel> refundVmFactory,
IOrderEntityFactory entityFactory, ReturnBuilder returnBuilder,
IViewModelsFactory <ILineItemAddViewModel> lineItemAddVmFactory,
IViewModelsFactory <IExchangeOrderStepViewModel> exchangeVmFactory,
IViewModelsFactory <IOrderAddressViewModel> addressVmFactory)
: base(innerOrder, rmaRequest, entityFactory, returnBuilder, returnItemsVmFactory, refundVmFactory, lineItemAddVmFactory, exchangeVmFactory)
{
_entityFactory = entityFactory;
_addressVmFactory = addressVmFactory;
_shippingRepositoryFactory = shippingRepositoryFactory;
_exchangeVmFactory = exchangeVmFactory;
}
public CreateRmaRequestViewModel(Foundation.Orders.Model.Order innerOrder,
RmaRequest rmaRequest, IOrderEntityFactory orderEntityFactory, ReturnBuilder returnBuilder,
IViewModelsFactory <IRmaRequestReturnItemsStepViewModel> returnItemsVmFactory,
IViewModelsFactory <IRmaRequestRefundStepViewModel> refundVmFactory,
IViewModelsFactory <ILineItemAddViewModel> lineItemAddVmFactory, IViewModelsFactory <IExchangeOrderStepViewModel> exchangeVmFactory)
{
_exchangeVmFactory = exchangeVmFactory;
_lineItemAddVmFactory = lineItemAddVmFactory;
_isCreatingExchangeOrderOnly = innerOrder.RmaRequests.Any(x => x.RmaRequestId == rmaRequest.RmaRequestId);
var item = innerOrder.DeepClone(orderEntityFactory as IKnownSerializationTypes);
ReturnBuilder = returnBuilder;
ReturnBuilder.WithOrderOrRmaRequest(item, rmaRequest);
CreateWizardSteps(returnItemsVmFactory, refundVmFactory);
}
public CreateRmaRequestViewModel(Foundation.Orders.Model.Order innerOrder,
RmaRequest rmaRequest, IOrderEntityFactory orderEntityFactory, ReturnBuilder returnBuilder,
IViewModelsFactory<IRmaRequestReturnItemsStepViewModel> returnItemsVmFactory,
IViewModelsFactory<IRmaRequestRefundStepViewModel> refundVmFactory,
IViewModelsFactory<ILineItemAddViewModel> lineItemAddVmFactory, IViewModelsFactory<IExchangeOrderStepViewModel> exchangeVmFactory)
{
_exchangeVmFactory = exchangeVmFactory;
_lineItemAddVmFactory = lineItemAddVmFactory;
_isCreatingExchangeOrderOnly = innerOrder.RmaRequests.Any(x => x.RmaRequestId == rmaRequest.RmaRequestId);
var item = innerOrder.DeepClone(orderEntityFactory as IKnownSerializationTypes);
ReturnBuilder = returnBuilder;
ReturnBuilder.WithOrderOrRmaRequest(item, rmaRequest);
CreateWizardSteps(returnItemsVmFactory, refundVmFactory);
}
internal MethodCandidate(OverloadResolver resolver, MethodBase method, List<ParameterWrapper> parameters, ParameterWrapper paramsDict,
ReturnBuilder returnBuilder, ArgBuilder instanceBuilder, IList<ArgBuilder> argBuilders) {
Assert.NotNull(resolver, method, instanceBuilder, returnBuilder);
Assert.NotNullItems(parameters);
Assert.NotNullItems(argBuilders);
_resolver = resolver;
_method = method;
_instanceBuilder = instanceBuilder;
_argBuilders = argBuilders;
_returnBuilder = returnBuilder;
_parameters = parameters;
_paramsDict = paramsDict;
_paramsArrayIndex = ParameterWrapper.IndexOfParamsArray(parameters);
parameters.TrimExcess();
}
private void SelectedItemsToAdd_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
if (e.Action == NotifyCollectionChangedAction.Add)
{
foreach (ILineItemViewModel item in e.NewItems)
{
ReturnBuilder.AddExchangeItem(item.ItemToAdd, item.Quantity);
}
}
else if (e.Action == NotifyCollectionChangedAction.Remove)
{
foreach (ILineItemViewModel item in e.OldItems)
{
var exchangeLineItem = ReturnBuilder.ExchangeLineItems.Where(x => x.CatalogItemId == item.ItemToAdd.ItemId).FirstOrDefault();
ReturnBuilder.RemoveExchangeItem(exchangeLineItem);
}
}
OnIsValidChanged();
}
internal MethodCandidate(OverloadResolver resolver, OverloadInfo method, List<ParameterWrapper> parameters, ParameterWrapper paramsDict,
ReturnBuilder returnBuilder, InstanceBuilder instanceBuilder, IList<ArgBuilder> argBuilders, Dictionary<DynamicMetaObject, BindingRestrictions> restrictions) {
Assert.NotNull(resolver, method, instanceBuilder, returnBuilder);
Assert.NotNullItems(parameters);
Assert.NotNullItems(argBuilders);
_resolver = resolver;
_overload = method;
_instanceBuilder = instanceBuilder;
_argBuilders = argBuilders;
_returnBuilder = returnBuilder;
_parameters = parameters;
_paramsDict = paramsDict;
_restrictions = restrictions;
_paramsArrayIndex = ParameterWrapper.IndexOfParamsArray(parameters);
parameters.TrimExcess();
}
private static List <MemberInfo> GetBindableMembers(ReturnBuilder returnBuilder, List <SymbolId> unusedNames)
{
List <MemberInfo> bindableMembers = new List <MemberInfo>();
foreach (SymbolId si in unusedNames)
{
string strName = SymbolTable.IdToString(si);
FieldInfo fi = returnBuilder.ReturnType.GetField(strName);
if (fi != null)
{
bindableMembers.Add(fi);
}
PropertyInfo pi = returnBuilder.ReturnType.GetProperty(strName);
if (pi != null)
{
bindableMembers.Add(pi);
}
}
return(bindableMembers);
}
public void SelectItem(object selectedObj)
{
var itemVM = _returnItemVmFactory.GetViewModelInstance();
itemVM.ReturnLineItem = selectedObj as ReturnBuilder.ReturnLineItem;
var confirmation = new ConditionalConfirmation {
Title = "Specify return data".Localize(), Content = itemVM
};
ReturnItemConfirmRequest.Raise(confirmation, (x) =>
{
if (x.Confirmed)
{
ReturnBuilder.AddReturnItem(itemVM.ReturnLineItem, itemVM.QuantityToMove, itemVM.SelectedReason);
// recalculate
// OnPropertyChanged("ReturnTotal");
OnIsValidChanged();
}
});
}
public RmaRequestReturnItemsStepViewModel(ReturnBuilder returnBuilder, IViewModelsFactory <IReturnItemViewModel> returnItemVmFactory)
: base(returnItemVmFactory, returnBuilder)
{
}
public RmaRequestReturnItemsStepViewModel(ReturnBuilder returnBuilder, IViewModelsFactory<IReturnItemViewModel> returnItemVmFactory)
: base(returnItemVmFactory, returnBuilder)
{
}
private MethodCandidate MakeByRefReducedMethodTarget(MethodBase method)
{
List <ParameterWrapper> parameters = new List <ParameterWrapper>();
int argIndex = 0;
ArgBuilder instanceBuilder;
if (!CompilerHelpers.IsStatic(method))
{
parameters.Add(new ParameterWrapper(_binder, method.DeclaringType, true));
instanceBuilder = new SimpleArgBuilder(argIndex++, parameters[0].Type);
}
else
{
instanceBuilder = new NullArgBuilder();
}
List <ArgBuilder> argBuilders = new List <ArgBuilder>();
List <int> returnArgs = new List <int>();
if (CompilerHelpers.GetReturnType(method) != typeof(void))
{
returnArgs.Add(-1);
}
int paramCount = 0;
foreach (ParameterInfo pi in method.GetParameters())
{
if (pi.ParameterType == typeof(CodeContext) && paramCount == 0)
{
argBuilders.Add(new ContextArgBuilder());
continue;
}
paramCount++;
int newIndex = 0, kwIndex = -1;
if (!CompilerHelpers.IsOutParameter(pi))
{
kwIndex = GetKeywordIndex(pi);
if (kwIndex == -1)
{
newIndex = argIndex++;
}
}
ArgBuilder ab;
if (CompilerHelpers.IsOutParameter(pi))
{
returnArgs.Add(argBuilders.Count);
ab = new OutArgBuilder(pi);
}
else if (pi.ParameterType.IsByRef)
{
returnArgs.Add(argBuilders.Count);
ParameterWrapper param = new ParameterWrapper(_binder, pi.ParameterType.GetElementType(), SymbolTable.StringToId(pi.Name));
parameters.Add(param);
ab = new ReturnReferenceArgBuilder(newIndex, pi.ParameterType.GetElementType());
}
else
{
ParameterWrapper param = new ParameterWrapper(_binder, pi);
parameters.Add(param);
ab = new SimpleArgBuilder(newIndex, param.Type, pi);
}
if (kwIndex == -1)
{
argBuilders.Add(ab);
}
else
{
argBuilders.Add(new KeywordArgBuilder(ab, _kwArgs.Length, kwIndex));
}
}
ReturnBuilder returnBuilder = MakeKeywordReturnBuilder(
new ByRefReturnBuilder(_binder, returnArgs),
method.GetParameters(),
parameters);
return(MakeMethodCandidate(method, parameters, instanceBuilder, argBuilders, returnBuilder));
}
private MethodCandidate MakeMethodCandidate(MethodBase method, List <ParameterWrapper> parameters, ArgBuilder instanceBuilder, List <ArgBuilder> argBuilders, ReturnBuilder returnBuilder)
{
return(new MethodCandidate(
new MethodTarget(this, method, parameters.Count, instanceBuilder, argBuilders, returnBuilder),
parameters));
}
private MethodCandidate MakeDefaultCandidate(MethodBase method, List <ParameterWrapper> parameters, ArgBuilder instanceBuilder, List <ArgBuilder> argBuilders, List <ArgBuilder> defaultBuilders, ReturnBuilder returnBuilder, int defaultsUsed)
{
List <ArgBuilder> defaultArgBuilders = new List <ArgBuilder>(argBuilders); // argBuilders.GetRange(0, argBuilders.Count - i);
List <ParameterWrapper> necessaryParams = parameters.GetRange(0, parameters.Count - defaultsUsed);
for (int curDefault = 0; curDefault < defaultsUsed; curDefault++)
{
int readIndex = defaultBuilders.Count - defaultsUsed + curDefault;
int writeIndex = defaultArgBuilders.Count - defaultsUsed + curDefault;
if (defaultBuilders[readIndex] != null)
{
defaultArgBuilders[writeIndex] = defaultBuilders[readIndex];
}
else
{
necessaryParams.Add(parameters[parameters.Count - defaultsUsed + curDefault]);
}
}
// shift any arguments forward that need to be...
int curArg = CompilerHelpers.IsStatic(method) ? 0 : 1;
for (int i = 0; i < defaultArgBuilders.Count; i++)
{
if (defaultArgBuilders[i] is DefaultArgBuilder ||
defaultArgBuilders[i] is ContextArgBuilder ||
defaultArgBuilders[i] is KeywordArgBuilder)
{
continue;
}
ReferenceArgBuilder rab = defaultArgBuilders[i] as ReferenceArgBuilder;
if (rab != null)
{
defaultArgBuilders[i] = new ReferenceArgBuilder(curArg++, rab.Type);
continue;
}
SimpleArgBuilder sab = (SimpleArgBuilder)defaultArgBuilders[i];
Debug.Assert(sab.GetType() == typeof(SimpleArgBuilder));
defaultArgBuilders[i] = new SimpleArgBuilder(curArg++, sab.Type, sab.IsParamsArray, sab.IsParamsDict);
}
return(MakeMethodCandidate(method, necessaryParams, instanceBuilder, defaultArgBuilders, returnBuilder));
}
private void AddBasicMethodTargets(MethodBase method)
{
List <ParameterWrapper> parameters = new List <ParameterWrapper>();
int argIndex = 0;
ArgBuilder instanceBuilder;
bool hasDefaults = false;
if (!CompilerHelpers.IsStatic(method))
{
parameters.Add(new ParameterWrapper(_binder, method.DeclaringType, true));
instanceBuilder = new SimpleArgBuilder(argIndex++, parameters[0].Type);
}
else
{
instanceBuilder = new NullArgBuilder();
}
ParameterInfo[] methodParams = method.GetParameters();
List <ArgBuilder> argBuilders = new List <ArgBuilder>(methodParams.Length);
List <ArgBuilder> defaultBuilders = new List <ArgBuilder>();
bool hasByRefOrOut = false;
foreach (ParameterInfo pi in methodParams)
{
if (pi.ParameterType == typeof(CodeContext) && argBuilders.Count == 0)
{
argBuilders.Add(new ContextArgBuilder());
continue;
}
int newIndex, kwIndex = GetKeywordIndex(pi);
if (kwIndex == -1)
{
if (!CompilerHelpers.IsMandatoryParameter(pi))
{
defaultBuilders.Add(new DefaultArgBuilder(pi.ParameterType, pi.DefaultValue));
hasDefaults = true;
}
else if (defaultBuilders.Count > 0)
{
defaultBuilders.Add(null);
}
newIndex = argIndex++;
}
else
{
defaultBuilders.Add(null);
newIndex = 0;
}
ArgBuilder ab;
if (pi.ParameterType.IsByRef)
{
hasByRefOrOut = true;
Type refType = typeof(StrongBox <>).MakeGenericType(pi.ParameterType.GetElementType());
ParameterWrapper param = new ParameterWrapper(_binder, refType, true, SymbolTable.StringToId(pi.Name));
parameters.Add(param);
ab = new ReferenceArgBuilder(newIndex, param.Type);
}
else
{
hasByRefOrOut |= CompilerHelpers.IsOutParameter(pi);
ParameterWrapper param = new ParameterWrapper(_binder, pi);
parameters.Add(param);
ab = new SimpleArgBuilder(newIndex, param.Type, pi);
}
if (kwIndex == -1)
{
argBuilders.Add(ab);
}
else
{
argBuilders.Add(new KeywordArgBuilder(ab, _kwArgs.Length, kwIndex));
}
}
ReturnBuilder returnBuilder = MakeKeywordReturnBuilder(
new ReturnBuilder(CompilerHelpers.GetReturnType(method)),
methodParams,
parameters);
if (hasDefaults)
{
for (int defaultsUsed = 1; defaultsUsed < defaultBuilders.Count + 1; defaultsUsed++)
{
// if the left most default we'll use is not present then don't add a default. This happens in cases such as:
// a(a=1, b=2, c=3) and then call with a(a=5, c=3). We'll come through once for c (no default, skip),
// once for b (default present, emit) and then a (no default, skip again). W/o skipping we'd generate the same
// method multiple times. This also happens w/ non-contigious default values, e.g. foo(a, b=3, c) where we don't want
// to generate a default candidate for just c which matches the normal method.
if (defaultBuilders[defaultBuilders.Count - defaultsUsed] != null)
{
AddTarget(MakeDefaultCandidate(
method,
parameters,
instanceBuilder,
argBuilders,
defaultBuilders,
returnBuilder,
defaultsUsed));
}
}
}
if (hasByRefOrOut)
{
AddSimpleTarget(MakeByRefReducedMethodTarget(method));
}
AddSimpleTarget(MakeMethodCandidate(method, parameters, instanceBuilder, argBuilders, returnBuilder));
}
public MethodTarget(MethodTracker method, List<Parameter> parameters, ArgBuilder instanceBuilder, List<ArgBuilder> argBuilders, ReturnBuilder returnBuilder)
{
this.method = method;
this.parameters = parameters;
this.instanceBuilder = instanceBuilder;
this.argBuilders = argBuilders;
this.returnBuilder = returnBuilder;
parameters.TrimExcess();
argBuilders.TrimExcess();
}
private void AddBasicMethodTargets(MethodTracker method)
{
List<Parameter> parameters = new List<Parameter>();
int argIndex = 0;
ArgBuilder instanceBuilder;
if (!method.IsStatic) {
parameters.Add(new Parameter(method.DeclaringType));
instanceBuilder = new SimpleArgBuilder(argIndex++, parameters[0]);
} else {
instanceBuilder = new NullArgBuilder();
}
List<ArgBuilder> argBuilders = new List<ArgBuilder>();
List<ArgBuilder> defaultBuilders = new List<ArgBuilder>();
bool hasByRef = false;
foreach (ParameterInfo pi in method.GetParameters()) {
if (pi.ParameterType == typeof(ICallerContext)) {
argBuilders.Add(new ContextArgBuilder());
continue;
}
if (pi.DefaultValue != DBNull.Value) {
defaultBuilders.Add(new DefaultArgBuilder(pi.ParameterType, pi.DefaultValue));
} else if (defaultBuilders.Count > 0) {
// If we get a bad method with non-contiguous default values, then just use the contiguous list
defaultBuilders.Clear();
}
if (pi.ParameterType.IsByRef) {
hasByRef = true;
Parameter param = new ByRefParameter(pi.ParameterType.GetElementType(), pi.IsOut && !pi.IsIn);
parameters.Add(param);
argBuilders.Add(new ReferenceArgBuilder(argIndex++, param));
} else {
Parameter param = new Parameter(pi.ParameterType);
parameters.Add(param);
argBuilders.Add(new SimpleArgBuilder(argIndex++, param));
}
}
ReturnBuilder returnBuilder = new ReturnBuilder(CompilerHelpers.GetReturnType(method.Method));
for (int i = 1; i < defaultBuilders.Count + 1; i++) {
List<ArgBuilder> defaultArgBuilders = argBuilders.GetRange(0, argBuilders.Count - i);
defaultArgBuilders.AddRange(defaultBuilders.GetRange(defaultBuilders.Count - i, i));
AddTarget(new MethodTarget(method, parameters.GetRange(0, parameters.Count - i),
instanceBuilder, defaultArgBuilders, returnBuilder));
}
if (hasByRef) AddSimpleTarget(MakeByRefReducedMethodTarget(method, parameters, instanceBuilder, argBuilders));
AddSimpleTarget(new MethodTarget(method, parameters, instanceBuilder, argBuilders, returnBuilder));
}
internal void MapParameters(bool reduceByRef) {
if (reduceByRef) {
_returnArgs = new List<int>();
if (_overload.ReturnType != typeof(void)) {
_returnArgs.Add(-1);
}
}
BitArray specialParameters = _resolver.MapSpecialParameters(this);
if (_instanceBuilder == null) {
_instanceBuilder = new InstanceBuilder(-1);
}
foreach (var parameter in _overload.Parameters) {
if (!IsSpecialParameter(specialParameters, parameter.Position)) {
if (reduceByRef) {
MapParameterReduceByRef(parameter);
} else {
MapParameter(parameter);
}
}
}
_returnBuilder = MakeReturnBuilder(specialParameters);
}
public RmaRequestRefundStepViewModel(ReturnBuilder returnBuilder, IPaymentMethodRepository repository, StoreClient client)
: base(null, returnBuilder)
{
var paymentMethodNames = ReturnBuilder.CurrentOrder.OrderForms[0].Payments.Select(x => x.PaymentMethodName).Distinct();
PaymentMethods = paymentMethodNames.ToArray();
NewPaymentSource = CreateRefundViewModel.GetNewPaymentModel(ReturnBuilder.CurrentOrder.InnerItem, repository, client);
}
public ExchangeOrderStepViewModel(IOrderEntityFactory entityFactory, IViewModelsFactory <IOrderAddressViewModel> addressVmFactory, ReturnBuilder returnBuilder, IViewModelsFactory <ILineItemAddViewModel> lineItemAddVmFactory, bool isCreatingExchangeOrderOnly, IRepositoryFactory <IShippingRepository> shippingRepositoryFactory)
: base(entityFactory, addressVmFactory, returnBuilder, lineItemAddVmFactory, isCreatingExchangeOrderOnly, null, shippingRepositoryFactory)
{
}
