public bool Eval(SongViewModel song)
{
switch (EvalType)
{
case MemberEvalType.Playlist:
PlaylistViewModel playlist = LibraryViewModel.Current.LookupPlaylistById(Target);
if (playlist == null)
{
return(false);
}
return(playlist.ContainsSong(song));
case MemberEvalType.Mix:
MixViewModel mix = LibraryViewModel.Current.LookupMixById(Target);
if (mix == null)
{
return(false);
}
return(mix.ContainsSong(song));
default:
DebugHelper.Alert(new CallerInfo(), "Unexpected MemberEvalType: {0}", EvalType);
return(false);
}
}
public async Task <ActionResult> ScheduleListByDate(string date)
{
ViewBag.dateTitle = date;
var schedules = DBLink.GetSchedules();
var employeeUsers = getEmployees();
var customerUsers = getCustomers();
List <MixViewModel> scheduleList = new List <MixViewModel>();
foreach (var schedule in schedules)
{
MixViewModel mymodel = new MixViewModel();
var userE = await UserManager.FindByIdAsync(schedule.employee_Id + "");
var userC = await UserManager.FindByIdAsync(schedule.customer_Id + "");
mymodel.employee = userE;
mymodel.schedule = schedule;
mymodel.customer = userC;
mymodel.task = DBLink.getTaskById(schedule.task_Id);
//if the employee's id is equal to the id we selected in UserList
System.Diagnostics.Debug.WriteLine(" schedule.date = " + schedule.date + ", date = " + date);
if (schedule.date == date)
{
scheduleList.Add(mymodel);
}
}
return(View("ScheduleList", scheduleList));
}
public MixItemViewModel(
IMessenger messenger,
IMixItem mixItem,
PlayPauseTrackCommand playPauseCommand,
IMix mix,
MixViewModel mixViewModel) : base(messenger)
{
this.mix = mix;
this.mixViewModel = mixViewModel;
if (messenger == null) throw new ArgumentNullException("messenger");
if (mixItem == null) throw new ArgumentNullException("mixItem");
if (playPauseCommand == null) throw new ArgumentNullException("playPauseCommand");
if (mix == null) throw new ArgumentNullException("mix");
if (mixViewModel == null) throw new ArgumentNullException("mixViewModel");
MixItem = mixItem;
PlayPauseCommand = playPauseCommand;
messenger.Register<TransitionChangedEvent>(this, OnTransitionChanged);
messenger.Register<PlaybackSpeedAdjustedEvent>(this, OnPlaybackSpeedAdjusted);
messenger.Register<TrackUpdatedEvent>(this, OnTrackUpdated);
messenger.Register<MixLockedEvent>(this, _ => RaisePropertyChanged(() => IsPitchFaderEnabled));
messenger.Register<MixUnlockedEvent>(this, _ => RaisePropertyChanged(() => IsPitchFaderEnabled));
// Required for play/pause status
messenger.Register<PlayerPlayingEvent>(this, _ => RaisePropertyChanged(() => Track));
messenger.Register<PlayerStoppedEvent>(this, _ => RaisePropertyChanged(() => Track));
messenger.Register<ConfigSavedEvent>(this, _ => RaisePropertyChanged(() => ActualKey));
}
public async Task <ActionResult> EmployeeSchedules(string id)
{
var schedules = DBLink.GetSchedules();
var employeeUsers = getEmployees();
var customerUsers = getCustomers();
List <MixViewModel> scheduleList = new List <MixViewModel>();
foreach (var schedule in schedules)
{
MixViewModel mymodel = new MixViewModel();
var userE = await UserManager.FindByIdAsync(schedule.employee_Id + "");
var userC = await UserManager.FindByIdAsync(schedule.customer_Id + "");
mymodel.employee = userE;
mymodel.schedule = schedule;
mymodel.customer = userC;
mymodel.task = DBLink.getTaskById(schedule.task_Id);
if (schedule.employee_Id == id)
{//if the employee's id is equal to the id we selected in UserList
scheduleList.Add(mymodel);
}
}
return(View("ScheduleList", scheduleList));
}
public async Task <ActionResult> Index()
{
MasterMixViewModel masterModel = new MasterMixViewModel();
var schedules = DBLink.GetSchedules();
var employeeUsers = getEmployees();
var customerUsers = getCustomers();
var relatives = DBLink.GetRelatives();
List <MixViewModel> scheduleList = new List <MixViewModel>();
foreach (var schedule in schedules)
{
MixViewModel mymodel = new MixViewModel();
var userE = await UserManager.FindByIdAsync(schedule.employee_Id + "");
var userC = await UserManager.FindByIdAsync(schedule.customer_Id + "");
mymodel.employee = userE;
mymodel.schedule = schedule;
mymodel.customer = userC;
mymodel.task = DBLink.getTaskById(schedule.task_Id);
//if the employee's id is equal to the id we selected in UserList
scheduleList.Add(mymodel);
}
masterModel.mixViewModel = scheduleList;
masterModel.relatives = relatives.ToList();
return(View(masterModel));
}
protected override Style SelectStyleCore(object item, DependencyObject container)
{
MixViewModel itemAsMixViewModel = DebugHelper.CastAndAssert <MixViewModel>(item);
if (itemAsMixViewModel.IsHidden)
{
return(EmptyStyle);
}
return(null);
}
public EditMix(MixViewModel mixToEdit)
{
this.InitializeComponent();
this.DataContext = mixToEdit;
SortTypeComboBox.ItemsSource = AllSortTypes;
SelectableOption<MixSortOrder> selectedTypeEntry = AllSortTypes.Where((m) => { return (m.Type == (Mix.SortType & MixSortOrder.PROPERTY_MASK) || m.Type == Mix.SortType); }).FirstOrDefault();
SortTypeComboBox.SelectedItem = selectedTypeEntry;
SortOrderComboBox.ItemsSource = AllSortOrders;
SelectableOption<MixSortOrder> selectedOrderEntry = AllSortOrders.Where((m) => { return (m.Type == (Mix.SortType & MixSortOrder.ORDER_MASK) || m.Type == Mix.SortType); }).FirstOrDefault();
SortOrderComboBox.SelectedItem = selectedOrderEntry;
RootMixEntry.LoadEvaluator(mixToEdit.RootEvaluator);
RootMixEntry.TextBotGotFocus += HandleMixLimitTextBoxGotFocus;
RootMixEntry.TextBotLostFocus += HandleMixLimitTextBoxLostFocus;
}
public EditMix(MixViewModel mixToEdit)
{
this.InitializeComponent();
this.DataContext = mixToEdit;
SortTypeComboBox.ItemsSource = AllSortTypes;
SelectableOption <MixSortOrder> selectedTypeEntry = AllSortTypes.Where((m) => { return(m.Type == (Mix.SortType & MixSortOrder.PROPERTY_MASK) || m.Type == Mix.SortType); }).FirstOrDefault();
SortTypeComboBox.SelectedItem = selectedTypeEntry;
SortOrderComboBox.ItemsSource = AllSortOrders;
SelectableOption <MixSortOrder> selectedOrderEntry = AllSortOrders.Where((m) => { return(m.Type == (Mix.SortType & MixSortOrder.ORDER_MASK) || m.Type == Mix.SortType); }).FirstOrDefault();
SortOrderComboBox.SelectedItem = selectedOrderEntry;
RootMixEntry.LoadEvaluator(mixToEdit.RootEvaluator);
RootMixEntry.TextBotGotFocus += HandleMixLimitTextBoxGotFocus;
RootMixEntry.TextBotLostFocus += HandleMixLimitTextBoxLostFocus;
}
public void SetUp()
{
fileSystemBrowserStub = new FileSystemBrowserStub();
downloadingMediaContent = Features.DownloadingMediaContent;
testScheduler = new TestScheduler();
origSched = RxApp.DeferredScheduler;
RxApp.DeferredScheduler = testScheduler;
aMix = new Mix(new MixElement(), 0);
lockObject = new ManualResetEvent(false);
audioPlayer = new AudioPlayerStub();
requestExecutor = new RequestExecutorStub();
playbackController = new PlaybackController(audioPlayer, requestExecutor);
mediaLibraryBrowser = new MediaLibraryBrowser(requestExecutor);
userLoggedInSubject = new Subject <bool>();
mixViewModel = new MixViewModel(aMix, playbackController, mediaLibraryBrowser, userLoggedInSubject);
mixViewModel.FileSystemBrowser = fileSystemBrowserStub;
mixViewModel.WebAccessProxy = new WebAccessProxyStub();
lockObject.Reset();
}
public async Task <ActionResult> ScheduleList()
{
var schedule = DBLink.GetSchedules();
var employeeUsers = getEmployees();
var customerUsers = getCustomers();
List <MixViewModel> scheduleList = new List <MixViewModel>();
foreach (var sched in schedule)
{
MixViewModel mymodel = new MixViewModel();
var userE = await UserManager.FindByIdAsync(sched.employee_Id + "");
var userC = await UserManager.FindByIdAsync(sched.customer_Id + "");
mymodel.employee = userE;
mymodel.schedule = sched;
mymodel.customer = userC;
mymodel.task = DBLink.getTaskById(sched.task_Id);
scheduleList.Add(mymodel);
}
return(View(scheduleList));
}
public MixItemViewModel CreateFor(IMix mix, IMixItem item, MixViewModel mixViewModel)
{
return new MixItemViewModel(messenger, item, playPauseCommand, mix, mixViewModel);
}
public IMixEvaluator ConvertToEvaluator()
{
if (MixEntryType.SelectedItem == null)
{
return(new NoneMixEvaluator());
}
SelectableOption <MixType> selectedType = DebugHelper.CastAndAssert <SelectableOption <MixType> >(MixEntryType.SelectedItem);
switch (selectedType.Type & MixType.TYPE_MASK)
{
case MixType.NUMBER_TYPE:
if (NumericPicker.SelectedItem == null)
{
return(new NoneMixEvaluator());
}
SelectableOption <NumericEvalType> selectedNumericType = DebugHelper.CastAndAssert <SelectableOption <NumericEvalType> >(NumericPicker.SelectedItem);
string newTarget = ConvertNumericValueToString(selectedType.Type);
return(MixViewModel.NumericMixEntryModelToMixEvaluator(selectedType.Type | NumericMixEvaluator <int> .NumericEvalTypeToMixTypeVariant(selectedNumericType.Type), newTarget));
case MixType.STRING_TYPE:
if (StringPicker.SelectedItem == null)
{
return(new NoneMixEvaluator());
}
SelectableOption <StringEvalType> selectedStringType = DebugHelper.CastAndAssert <SelectableOption <StringEvalType> >(StringPicker.SelectedItem);
return(MixViewModel.StringMixEntryModelToMixEvaluator(selectedType.Type | StringMixEvaluator.StringEvalTypeToMixTypeVariant(selectedStringType.Type), StringValue.Text));
case MixType.NESTED_TYPE:
List <IMixEvaluator> mixes = new List <IMixEvaluator>();
foreach (object listItem in NestedList.Children)
{
MixEntry listItemAsMixEntry = DebugHelper.CastAndAssert <MixEntry>(listItem);
mixes.Add(listItemAsMixEntry.ConvertToEvaluator());
}
return(MixViewModel.NestedMixEntryModelToMixEvaluator(selectedType.Type, mixes));
case MixType.RANGE_TYPE:
return(MixViewModel.RangeMixEntryModelToMixEvaluator(selectedType.Type | RangeMixEvaluator.RangeEvalTypeToMixTypeVariant(RangeEvalType.Days), RangeValue.Text));
case MixType.MEMBER_TYPE:
if (selectedType.Type == MixType.PLAYLISTMEMBER_SUBTYPE)
{
if (PlaylistMemberPicker.SelectedItem == null)
{
return(new NoneMixEvaluator());
}
PlaylistViewModel selectedPlaylist = DebugHelper.CastAndAssert <PlaylistViewModel>(PlaylistMemberPicker.SelectedItem);
return(MixViewModel.MemberMixEntryModelToMixEvaluator(MixType.PlaylistMemberContains, selectedPlaylist.PlaylistId.ToString()));
}
else if (selectedType.Type == MixType.MIXMEMBER_SUBTYPE)
{
if (MixMemberPicker.SelectedItem == null)
{
return(new NoneMixEvaluator());
}
MixViewModel selectedMix = DebugHelper.CastAndAssert <MixViewModel>(MixMemberPicker.SelectedItem);
return(MixViewModel.MemberMixEntryModelToMixEvaluator(MixType.MixMemberContains, selectedMix.MixId.ToString()));
}
else
{
DebugHelper.Alert(new CallerInfo(), "Unexpected member type: {0}", selectedType);
return(new NoneMixEvaluator());
}
default:
DebugHelper.Assert(new CallerInfo(), selectedType.Type == MixType.None, "Unexpected mix type: {0}", selectedType.Type);
return(new NoneMixEvaluator());
}
}
public void LoadEvaluator(IMixEvaluator evaluator)
{
MixType mixType = evaluator.MixType;
SelectableOption <MixType> selectedMixTypeEntry = AllMixTypes.Where((m) => { return(m.Type == (mixType & MixType.SUBTYPE_MASK) || m.Type == mixType); }).FirstOrDefault();
MixEntryType.SelectedItem = selectedMixTypeEntry;
switch (mixType & MixType.TYPE_MASK)
{
case MixType.NUMBER_TYPE:
NumericMixEvaluator <IComparable> numericEvaluator = DebugHelper.CastAndAssert <NumericMixEvaluator <IComparable> >(evaluator);
SelectableOption <NumericEvalType> selectedNumericTypeEntry = NumericInfo.Where((m) => { return(m.Type == numericEvaluator.EvalType); }).FirstOrDefault();
NumericPicker.SelectedItem = selectedNumericTypeEntry;
UpdateNumericStartingValue(mixType, numericEvaluator.Target);
return;
case MixType.STRING_TYPE:
StringMixEvaluator stringEvaluator = DebugHelper.CastAndAssert <StringMixEvaluator>(evaluator);
SelectableOption <StringEvalType> selectedStringTypeEntry = StringInfo.Where((m) => { return(m.Type == stringEvaluator.EvalType); }).FirstOrDefault();
StringPicker.SelectedItem = selectedStringTypeEntry;
StringValue.Text = stringEvaluator.Target;
return;
case MixType.NESTED_TYPE:
NestedMixEvaluator nestedEvaluator = DebugHelper.CastAndAssert <NestedMixEvaluator>(evaluator);
foreach (IMixEvaluator mixEvaluator in nestedEvaluator.Mixes)
{
MixEntry nestedEntry = new MixEntry(this, Depth + 1);
nestedEntry.LoadEvaluator(mixEvaluator);
NestedList.Children.Add(nestedEntry);
nestedEntry.TextBotGotFocus += HandleTextBoxGotFocus;
nestedEntry.TextBotLostFocus += HandleTextBoxLostFocus;
}
return;
case MixType.MEMBER_TYPE:
MemberMixEvaluator memberEvaluator = DebugHelper.CastAndAssert <MemberMixEvaluator>(evaluator);
if ((mixType & MixType.SUBTYPE_MASK) == MixType.PLAYLISTMEMBER_SUBTYPE)
{
PlaylistViewModel playlist = LibraryViewModel.Current.LookupPlaylistById(memberEvaluator.Target);
PlaylistMemberPicker.SelectedItem = playlist;
}
else if ((mixType & MixType.SUBTYPE_MASK) == MixType.MIXMEMBER_SUBTYPE)
{
MixViewModel mix = LibraryViewModel.Current.LookupMixById(memberEvaluator.Target);
MixMemberPicker.SelectedItem = mix;
}
else
{
DebugHelper.Alert(new CallerInfo(), "Unexpected member type: {0}", mixType);
return;
}
return;
case MixType.RANGE_TYPE:
RangeMixEvaluator rangeEvaluator = DebugHelper.CastAndAssert <RangeMixEvaluator>(evaluator);
RangeValue.Text = rangeEvaluator.Target.ToString();
return;
default:
DebugHelper.Assert(new CallerInfo(), mixType == MixType.None, "Unexpected mix type: {0}", mixType);
VisualStateManager.GoToState(this, "UnknownSelected", false);
return;
}
}
internal void DeleteMix(MixViewModel mix)
{
mix.IsBeingDeleted = true;
LibraryModel.Current.DeleteMix(mix.MixId);
}
public MixViewModel LookupMix(MixModel mix)
{
if (MixLookupMap.ContainsKey(mix.MixId))
{
return MixLookupMap[mix.MixId];
}
else
{
MixViewModel newViewModel = new MixViewModel(mix);
MixLookupMap.Add(newViewModel.MixId, newViewModel);
MixCollection.Add(newViewModel);
return newViewModel;
}
}
