public BasicGameClass(IGamePackageResolver mainContainer,
IEventAggregator aggregator,
BasicData basicData,
TestOptions test,
IViewModelData currentMod,
IMultiplayerSaveState state,
IAsyncDelayer delay,
CommandContainer command,
BasicGameContainer <P, S> gameContainer
)
{
MainContainer = mainContainer;
Aggregator = aggregator;
BasicData = basicData;
Test = test;
_currentMod = currentMod;
State = state;
Delay = delay;
_command = command;
_gameContainer = gameContainer;
SaveRoot = mainContainer.Resolve <S>(); //i think this would be fine (?)
PlayerList = SaveRoot.PlayerList;
gameContainer.EndTurnAsync = EndTurnAsync;
gameContainer.ContinueTurnAsync = ContinueTurnAsync;
gameContainer.ShowWinAsync = ShowWinAsync;
gameContainer.StartNewTurnAsync = StartNewTurnAsync;
gameContainer.SaveStateAsync = SaveStateAsync;
//if i need anything else, rethink.
Network = gameContainer.Network;
Check = gameContainer.Check;
}
public TaskController(ICommandBus commandBus, IMappingEngine mappingEngine, IIdentity identity, IViewModelData viewModelData)
{
_commandBus = commandBus;
_mappingEngine = mappingEngine;
_identity = identity;
_viewModelData = viewModelData;
}
public TaskController(ICommandBus commandBus, IMappingEngine mappingEngine, IIdentity identity, IViewModelData viewModelData)
{
_commandBus = commandBus;
_mappingEngine = mappingEngine;
_identity = identity;
_viewModelData = viewModelData;
}
public CandylandMainViewModel(CommandContainer commandContainer,
CandylandMainGameClass mainGame,
IViewModelData viewModel,
BasicData basicData,
TestOptions test,
IGamePackageResolver resolver
)
: base(commandContainer, mainGame, viewModel, basicData, test, resolver)
{
}
public override IEnumerable GetPropertyValues(IViewModelData modelData, IModelProperty property, IViewModelFactory factory)
{
IEnumerable result = null;
if (modelData is IPageData)
{
var cpModels = (modelData as IPageData).ComponentPresentations;
result = GetPresentationValues(cpModels, property, factory);
}
return result;
}
private readonly TicTacToeMainGameClass _mainGame; //if we don't need, delete.
public TicTacToeMainViewModel(CommandContainer commandContainer,
TicTacToeMainGameClass mainGame,
IViewModelData viewModel,
BasicData basicData,
TestOptions test,
IGamePackageResolver resolver
)
: base(commandContainer, mainGame, viewModel, basicData, test, resolver)
{
_mainGame = mainGame;
}
public LottoDominosMainViewModel(CommandContainer commandContainer,
LottoDominosMainGameClass mainGame,
IViewModelData viewModel,
BasicData basicData,
TestOptions test,
IGamePackageResolver resolver
)
: base(commandContainer, mainGame, viewModel, basicData, test, resolver)
{
_mainGame = mainGame;
_resolver = resolver;
}
public BasicMultiplayerMainVM(CommandContainer commandContainer,
IEndTurn mainGame,
IViewModelData viewModel,
BasicData basicData,
TestOptions test,
IGamePackageResolver resolver
)
{
CommandContainer = commandContainer;
CommandContainer.IsExecuting = true; //has to be proven false.
CommandContainer.ManuelFinish = true;
_mainGame = mainGame;
_viewModel = viewModel;
_basicData = basicData;
_test = test;
_resolver = resolver;
_viewModel.PropertyChanged += ViewModelPropertyChange;
if (_basicData.MultiPlayer)
{
_network = Resolve <INetworkMessages>();
}
Type type = GetType();
var ourProperties = type.GetPropertiesWithAttribute <VMAttribute>().ToCustomBasicList();
if (ourProperties.Count == 0)
{
throw new BasicBlankException("There has to be at least one property on the list. Rethink");
}
type = _viewModel.GetType();
var vmProperties = type.GetPropertiesWithAttribute <VMAttribute>().ToCustomBasicList();
vmProperties.ForEach(p =>
{
var o = ourProperties.Where(x => x.Name == p.Name).SingleOrDefault();
var v = p;
if (o != null)
{
PropertyLink link = new PropertyLink();
link.VMProperty = v;
link.OurProperty = o;
_properties.Add(link);
//set the values as well.
o.SetValue(this, v.GetValue(_viewModel));
}
});
}
public ThreeLetterFunMainViewModel(CommandContainer commandContainer,
ThreeLetterFunMainGameClass mainGame,
IViewModelData viewModel,
BasicData basicData,
TestOptions test,
IGamePackageResolver resolver,
GiveUpClass giveUp,
GameBoard board,
GlobalHelpers global
)
: base(commandContainer, mainGame, viewModel, basicData, test, resolver)
{
_mainGame = mainGame;
_basicData = basicData;
_giveUp = giveUp;
_board = board;
_global = global;
}
public override IEnumerable GetPropertyValues(IViewModelData modelData, IModelProperty property, IViewModelFactory factory)
{
IEnumerable result = null;
if (modelData != null)
{
if (modelData is IComponentPresentationData)
{
var cpData = modelData as IComponentPresentationData;
if (cpData != null)
{
result = GetPropertyValues(cpData.Component, property,
cpData.Template, factory);
}
}
else if (modelData is IComponentData) //Not all components come with Templates
{
result = GetPropertyValues(modelData as IComponentData, property, null, factory);
}
}
return result;
}
public BingoMainViewModel(CommandContainer commandContainer,
BingoMainGameClass mainGame,
IViewModelData viewModel,
BasicData basicData,
TestOptions test,
IGamePackageResolver resolver
)
: base(commandContainer, mainGame, viewModel, basicData, test, resolver)
{
_mainGame = mainGame;
_basicData = basicData;
_test = test;
_timer = new Timer();
_timer.Enabled = false;
_timer.Interval = 6000;
_timer.Elapsed += TimerElapsed;
_mainGame.SetTimerEnabled = ((rets =>
{
_timer.Enabled = rets;
}));
}
public bool IsMatch(IViewModelData data, string key)
{
bool result = false;
if (data is IDefinedData)
{
var definedData = data as IDefinedData;
var compare = new ViewModelAttribute(definedData.Schema.Title, false)
{
ViewModelKeys = key == null ? null : new string[] { key }
};
result = this.Equals(compare);
}
return result;
}
public override IEnumerable GetPropertyValues(IViewModelData modelData, IModelProperty property, IViewModelFactory factory)
{
IEnumerable result = null;
if (modelData != null && modelData is IKeywordData)
{
result = new IKeywordData[] { modelData as IKeywordData };
}
return result;
}
public bool IsMatch(IViewModelData data, string key)
{
bool result = false;
if (data is IKeywordData)
{
return ViewModelKeys.Any(x => x.Equals(key));
}
return result;
}
public abstract IEnumerable GetPropertyValues(IViewModelData modelData, IModelProperty property, IViewModelFactory factory);
protected override Type GetModelType(IViewModelData data, IViewModelFactory factory)
{
return KeywordType;
}
protected virtual object BuildModel(IViewModelFactory factory, IViewModelData data)
{
object result = null;
if (ComplexTypeMapping != null)
{
result = factory.BuildMappedModel(data, ComplexTypeMapping);
}
else
{
var modelType = GetModelType(data, factory);
result = modelType != null ? factory.BuildViewModel(modelType, data) : null;
}
return result;
}
protected override Type GetModelType(IViewModelData data, IViewModelFactory factory)
{
Type result = null;
try
{
result = factory.FindViewModelByAttribute<IDefinedModelAttribute>(data, LinkedComponentTypes);
}
catch (ViewModelTypeNotFoundException)
{
result = null;
}
return result;
}
protected override Type GetModelType(IViewModelData data, IViewModelFactory factory)
{
return EmbeddedModelType;
}
public override IEnumerable GetPropertyValues(IViewModelData modelData, IModelProperty property, IViewModelFactory factory)
{
IEnumerable result = null;
if (modelData != null)
{
//need null checks on Template
IFieldsData fields = null;
if (IsTemplateMetadata && modelData is ITemplatedViewModelData)
{
var templateData = modelData as ITemplatedViewModelData;
fields = templateData.Template != null ? templateData.Template.Metadata : null;
}
else if (IsMetadata)
{
fields = modelData.Metadata;
}
else if (modelData is IContentPresentationData)
{
fields = (modelData as IContentPresentationData).Content;
}
else
{
fields = modelData.Metadata;
}
if (String.IsNullOrEmpty(FieldName)) FieldName = GetFieldName(property.Name); //Convention over configuration by default -- Field name = Property name
if (fields != null && fields.ContainsKey(FieldName))
{
var template = modelData is ITemplatedViewModelData ? (modelData as ITemplatedViewModelData).Template
: null;
result = this.GetFieldValues(fields[FieldName], property, template, factory);
}
}
return result;
}
public override IEnumerable GetPropertyValues(IViewModelData modelData, IModelProperty property, IViewModelFactory factory)
{
IEnumerable result = null;
if (modelData is IContentPresentationData
&& (modelData as IContentPresentationData).Template is ITemplateData)
{
var templateData = (modelData as IContentPresentationData).Template as ITemplateData;
result = this.GetPropertyValues(templateData, property, factory);
}
return result;
}
protected abstract Type GetModelType(IViewModelData data, IViewModelFactory factory);
//TODO: REfactor to check type and use other overloads
public ViewModelTypeNotFoundException(IViewModelData data)
: base(String.Format("Could not find view model for item with Publication ID '{0}'", data.PublicationId))
{
}
public bool IsMatch(IViewModelData data, IViewModelKeyProvider provider)
{
var key = provider.GetViewModelKey(data);
return IsMatch(data, key);
}
public bool IsMatch(IViewModelData data, string key)
{
bool result = false;
if (data is IPageData)
{
var contentData = data as IPageData;
return ViewModelKeys.Any(x => x.Equals(key));
}
return result;
}
public override IEnumerable GetPropertyValues(IViewModelData modelData, IModelProperty property, IViewModelFactory factory)
{
IEnumerable result = null;
if (modelData is IPageData)
{
var pageModel = (modelData as IPageData);
result = this.GetPropertyValues(pageModel, property, factory);
}
return result;
}
