public void SetUp()
{
_screenServiceMock = new Mock <IScreenService>();
_dialogServiceMock = new Mock <IDialogService>();
_optimalWithServiceMock = new Mock <IUniqueWithFinderService>();
_screenViewModel = new ScreenViewModel(_screenServiceMock.Object, _dialogServiceMock.Object, _optimalWithServiceMock.Object);
}
public void RoutedViewHost_Should_Stay_In_Sync_With_RoutingState()
{
var screen = new ScreenViewModel();
var defaultContent = new TextBlock();
var host = new RoutedViewHost
{
Router = screen.Router,
DefaultContent = defaultContent,
FadeOutAnimation = null,
FadeInAnimation = null
};
var root = new TestRoot
{
Child = host
};
Assert.NotNull(host.Content);
Assert.Equal(typeof(TextBlock), host.Content.GetType());
Assert.Equal(defaultContent, host.Content);
var first = new FirstRoutableViewModel();
screen.Router.Navigate
.Execute(first)
.Subscribe();
Assert.NotNull(host.Content);
Assert.Equal(typeof(FirstRoutableView), host.Content.GetType());
Assert.Equal(first, ((FirstRoutableView)host.Content).DataContext);
Assert.Equal(first, ((FirstRoutableView)host.Content).ViewModel);
var second = new SecondRoutableViewModel();
screen.Router.Navigate
.Execute(second)
.Subscribe();
Assert.NotNull(host.Content);
Assert.Equal(typeof(SecondRoutableView), host.Content.GetType());
Assert.Equal(second, ((SecondRoutableView)host.Content).DataContext);
Assert.Equal(second, ((SecondRoutableView)host.Content).ViewModel);
screen.Router.NavigateBack
.Execute(Unit.Default)
.Subscribe();
Assert.NotNull(host.Content);
Assert.Equal(typeof(FirstRoutableView), host.Content.GetType());
Assert.Equal(first, ((FirstRoutableView)host.Content).DataContext);
Assert.Equal(first, ((FirstRoutableView)host.Content).ViewModel);
screen.Router.NavigateBack
.Execute(Unit.Default)
.Subscribe();
Assert.NotNull(host.Content);
Assert.Equal(typeof(TextBlock), host.Content.GetType());
Assert.Equal(defaultContent, host.Content);
}
public Metadata AllowPermission(string Controller, string Action, AccessLevel Accesslevel = AccessLevel.AllowRead)
{
Metadata res = new Metadata();
try
{
ScreenViewModel dataMenu = (from s in _context.Screen
join sr in _context.RoleScreen on s.screenid equals sr.screenid
join r in _context.Roles on sr.roleid equals r.roleid
where s.controllername.ToLower().Replace(" ", "") == Controller.ToLower().Replace(" ", "") && /*&& s.ActionName == Action*/
r.rolename.ToLower().Replace(" ", "") == _httpContext.User.GetUserRole().ToLower().Replace(" ", "") && ((Accesslevel == AccessLevel.AllowRead && sr.readflag == true) || (Accesslevel == AccessLevel.AllowWrite && sr.writeflag == true) ||
(Accesslevel == AccessLevel.AllowDelete && sr.deleteflag == true))
select new ScreenViewModel()
{
ActionName = s.actionname,
ControllerName = s.controllername,
IsActive = s.isactive,
IsMenu = s.ismenu,
ParentID = s.parentid,
ScreenID = s.screenid,
ScreenName = s.screenname
}).FirstOrDefault();
res.status = dataMenu != null;
}
catch (Exception e)
{
res.data = e.Message.ToString();
}
return(res);
}
public ScreenArea(ScreenViewModel dataContext)
{
InitializeComponent();
Cursor = Cursors.Cross;
WindowStartupLocation = WindowStartupLocation.Manual;
DataContext = dataContext;
}
public void ElementList_ThreeLayerAndChangeSize_FreeOpacityMask()
{
var factories = new IElementFactoryViewModel<IElementViewModel>[]
{
new PortiereFactoryViewModel(),
new PleatFactoryViewModel(),
new TulleFactoryViewModel()
};
var screen = new ScreenViewModel()
{
Width = 4,
Height = 2
};
var workspace = new WorkspaceViewModel()
{
Factories = factories,
Screen = screen,
CommandFactory = MockRepository.GenerateStub<ICommandFactory>(),
SettingProvider = MockRepository.GenerateStub<ISettingProvider>()
};
var elementList = workspace.ElementList;
elementList.AppendElement(factories[0]);
elementList.AppendElement(factories[1]);
elementList.AppendElement(factories[2]);
Assert.That(elementList.Count(), Is.EqualTo(3));
Assert.That(elementList.Collection.Last().Layout.OpacityMask, Is.Null);
screen.Width = 5;
Assert.That(elementList.Collection.Last().Layout.OpacityMask, Is.Null);
}
public void ElementList_AddAllElement_NoError()
{
var factories = new IElementFactoryViewModel<IElementViewModel>[]
{
new PortiereFactoryViewModel(),
new PleatFactoryViewModel(),
new TulleFactoryViewModel(),
new TieBackFactoryViewModel(),
new PanelFactoryViewModel(),
new HardPelmetFactoryViewModel(),
new ApplicationFactoryViewModel(),
new ScanFactoryViewModel(),
new OverlayFactoryViewModel(),
new FilletFactoryViewModel(),
new EqualSwagFactoryViewModel(),
new EqualTailFactoryViewModel(),
new ScaleneSwagFactoryViewModel(),
new ScaleneTailFactoryViewModel(),
new DeJabotFactoryViewModel(),
new LatticeFactoryViewModel(),
new RomanBlindFactoryViewModel()
};
var screen = new ScreenViewModel()
{
Width = 4,
Height = 2
};
var settingData = MockRepository.GenerateStub<ISettingData>();
settingData.Stub(sd => sd.ProgramName).Return("MyName");
settingData.Stub(sd => sd.Version).Return("1.0.0.0");
var settingProvider = MockRepository.GenerateStub<ISettingProvider>();
settingProvider.Stub(sp => settingProvider.GetSettingData()).Return(settingData);
var workspace = new WorkspaceViewModel()
{
Factories = factories,
Screen = screen,
CommandFactory = MockRepository.GenerateStub<ICommandFactory>(),
SettingProvider = settingProvider
};
var elementList = workspace.ElementList;
factories.ToList()
.ForEach(factory => elementList.AppendElement(factory));
Assert.That(elementList.Count(), Is.EqualTo(factories.Length));
var dataTransfer = workspace.Save();
Assert.DoesNotThrow(() =>
{
var serializer = new XmlSerializer(StandardXmlPrimitive.Primitives, dataTransfer);
serializer.Serialize();
});
workspace.Restore(dataTransfer);
Assert.That(elementList.Count(), Is.EqualTo(factories.Length));
}
public ScreenVisualViewModel(VisualOptions visualOptions, ScreenViewModel element)
{
VisualOptions = visualOptions;
Element = element;
Element
.SetPropertyChanged(nameof(Element.Width), () => OnPropertyChanged(nameof(Width)))
.SetPropertyChanged(nameof(Element.Height), () => OnPropertyChanged(nameof(Height)));
}
public ActionResult NewScreen(TheatreViewModel tvm)
{
ScreenViewModel obj = new ScreenViewModel()
{
theatreList = db.Theatres.Where(temp => temp.CityId == tvm.theatre.CityId).ToList()
};
return(View(obj));
}
protected override void OnAttached()
{
window = AssociatedObject as Window;
viewModel = (ScreenViewModel)window.DataContext;
viewModel.PropertyChanged += OnPropertyChanged;
AssociatedObject.Initialized += OnInitialized;
}
public ActionResult Index()
{
var screenView = new ScreenViewModel
{
ModuleList = new SelectList(_moduleService.GetAll(), "Id", "Name"),
ScreenTypeList = new SelectList(_screenService.GetScreenTypeList(), "Value", "Text"),
};
return(View(screenView));
}
public static DocumentPaneViewModel GetViewModel(ScreenViewModel model, SimpleContentCommand command)
{
DocumentPaneViewModel dpvm = null;
model.UiDispatcher.Invoke(() =>
{
dpvm = GetViewModelInvoked(model, command);
});
return(dpvm);
}
public ScreenView()
{
_savedNodes = new Dictionary <Node, UIElement>();
InitializeComponent();
_viewModel = DataContext as ScreenViewModel;
_viewModel.LoadImage += OnLoadImage;
_viewModel.NewTemporaryHierarchyNode += OnNewTemporaryHierarchyNode;
_viewModel.HierarchyNodeAdded += OnHierarchyNodeAdded;
_viewModel.NodeRemoved += OnNodeRemoved;
}
async void OnSaveClicked()
{
if (_unknownWidth)
{
_model.Width = null;
}
else if (_model.Width < 0)
{
return;
}
if (_unknownHeight)
{
_model.Height = null;
}
else if (_model.Height < 0)
{
return;
}
if (_unknownType)
{
_model.Type = null;
}
else if (string.IsNullOrWhiteSpace(_model.Type))
{
return;
}
if (_unknownColors)
{
_model.EffectiveColors = null;
}
else if (_model.EffectiveColors < 0)
{
return;
}
if (_creating)
{
Id = await Service.CreateAsync(_model, (await UserManager.GetUserAsync(_authState.User)).Id);
}
else
{
await Service.UpdateAsync(_model, (await UserManager.GetUserAsync(_authState.User)).Id);
}
_editing = false;
_creating = false;
_model = await Service.GetAsync(Id);
SetCheckboxes();
StateHasChanged();
}
public BuySellViewModel(ScreenViewModel model)
{
_model = model;
BuyViewModel = new BuyViewModel();
SellViewModel = new SellViewModel();
OrderBookBuyViewModel = new OrderBookViewModel(this);
OrderBookSellViewModel = new OrderBookViewModel(this);
OpenOrdersViewModel = new OpenOrdersViewModel(this);
MarketHistoryViewModel = new MarketHistoryViewModel(this);
MyOrderHistoryViewModel = new MyOrderHistoryViewModel(this);
}
public async Task <IActionResult> Edit(ScreenViewModel model)
{
ViewData["Title"] = "Edit Application Screen";
ViewData["parent"] = Parent;
if (ModelState.IsValid)
{
var res = await _repo.Update(model);
return(Json(res));
}
return(PartialView("_Edit", model));
}
public async Task <IActionResult> Add(ScreenViewModel model)
{
ViewData["Title"] = "Add Application Screen";
ViewData["parent"] = Parent;
if (ModelState.IsValid)
{
var res = await _repo.Insert(model);
return(Json(res));
}
return(PartialView("_Add", model));
}
public void RoutedViewHost_Should_Stay_In_Sync_With_RoutingState()
{
var screen = new ScreenViewModel();
var defaultContent = new TextBlock();
var host = new RoutedViewHost
{
Router = screen.Router,
DefaultContent = defaultContent,
PageTransition = null
};
var root = new TestRoot
{
Child = host
};
Dispatcher.UIThread.RunJobs(DispatcherPriority.Loaded);
Assert.NotNull(host.Content);
Assert.IsType <TextBlock>(host.Content);
Assert.Equal(defaultContent, host.Content);
var first = new FirstRoutableViewModel();
screen.Router.Navigate.Execute(first).Subscribe();
Assert.NotNull(host.Content);
Assert.IsType <FirstRoutableView>(host.Content);
Assert.Equal(first, ((FirstRoutableView)host.Content).DataContext);
Assert.Equal(first, ((FirstRoutableView)host.Content).ViewModel);
var second = new SecondRoutableViewModel();
screen.Router.Navigate.Execute(second).Subscribe();
Assert.NotNull(host.Content);
Assert.IsType <SecondRoutableView>(host.Content);
Assert.Equal(second, ((SecondRoutableView)host.Content).DataContext);
Assert.Equal(second, ((SecondRoutableView)host.Content).ViewModel);
screen.Router.NavigateBack.Execute(Unit.Default).Subscribe();
Assert.NotNull(host.Content);
Assert.IsType <FirstRoutableView>(host.Content);
Assert.Equal(first, ((FirstRoutableView)host.Content).DataContext);
Assert.Equal(first, ((FirstRoutableView)host.Content).ViewModel);
screen.Router.NavigateBack.Execute(Unit.Default).Subscribe();
Assert.NotNull(host.Content);
Assert.IsType <TextBlock>(host.Content);
Assert.Equal(defaultContent, host.Content);
}
public async Task <CreateScreenResponse> Handle(CreateScreenCommand message)
{
var cinema = await _cinemaRepository.GetCinemaById(message.CinemaId);
var screen = cinema.CreateScreen(
message.ScreenName,
message.ScreenRows,
message.ScreenSeatsPerRow);
await _cinemaRepository.UnitOfWork.CommitAsync();
return(new CreateScreenResponse(ScreenViewModel.FromScreen(screen)));
}
private DocumentPaneViewModel GetInstance(ScreenViewModel model, SimpleContentCommand command)
{
var panel = SimplePageUriProvider.GetViewModel(model, command);
if (panel != null)
{
panel.CanClose = true;
panel.IsActive = true;
panel.IsSelected = true;
}
return(panel);
}
public ActionResult GwvOf(ScreenViewModel model)
{
if (model.GivenPassword == models["GwvOf"].PasswordSolution)
{
models["GwvOf"].IsSuccess = true;
//return RedirectToAction(models["GwvOf"].Next);
}
else
{
models["GwvOf"].IsError = true;
}
return(View("Screen", models["GwvOf"]));
}
public ActionResult NewScreen(TheatreViewModel tvm)
{
var theatreList = getTheatreList();
var filter = theatreList.Where(temp => temp.CityId == tvm.theatre.CityId).ToList();
ScreenViewModel obj = new ScreenViewModel()
{
theatreList = filter
// theatreList = db.Theatres.Where(temp => temp.CityId == tvm.theatre.CityId).ToList()
};
return(View(obj));
}
public void UpdateValues(IDictionary <PaletteComponent, object> values)
{
ScreenViewModel.UpdateValues(values);
switch (SelectedIndex)
{
case 1:
UpdateXamlCode();
break;
case 2:
UpdateStyleCode();
break;
}
}
public async Task <Metadata> Update(ScreenViewModel model)
{
Metadata res = new Metadata();
try
{
var dataScreen = await context.Screen.AnyAsync(x => x.screenname.ToLower().Replace(" ", "") == model.ScreenName.ToLower().Replace(" ", "") && x.screenid != model.ScreenID);
if (dataScreen)
{
return new Metadata()
{
status = false, data = "Screen name is ready"
}
}
;
var data = await context.Screen.Where(x => x.screenid == model.ScreenID).FirstOrDefaultAsync();
if (data == null)
{
return new Metadata()
{
status = false, data = "Screen not found"
}
}
;
data.screenid = model.ScreenID;
data.screenname = model.ScreenName;
data.controllername = model.ControllerName;
data.actionname = model.ActionName;
data.ismenu = model.IsMenu;
data.isactive = model.IsActive;
data.parentid = model.ParentID;
data.iconcss = model.IconCss;
await context.SaveChangesAsync();
res.status = true;
res.data = "Data was successfully updated";
}
catch (Exception ex)
{
res.status = false;
res.data = ex.Message;
}
return(res);
}
async void OnCancelClicked()
{
_editing = false;
if (_creating)
{
NavigationManager.ToBaseRelativePath("admin/screens");
return;
}
_model = await Service.GetAsync(Id);
SetCheckboxes();
StateHasChanged();
}
public ActionResult YtYXK(ScreenViewModel model)
{
if (model.GivenPassword == models["YtYXK"].PasswordSolution ||
model.GivenPassword == "++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>++++++++++++. -. --. ++. ------------. +++++++++++. -------------." ||
model.GivenPassword == "++++++++++ [->++++++++++<] > ++++++++++++.- .--.+ +.< +++[->---<] >---.< +++[- > +++< ] > ++. < +++[ ->--- <] > ----.< +++++++++[- > ---------<] > ---.-- - .<")
{
models["YtYXK"].IsSuccess = true;
//return RedirectToAction(models["YtYXK"].Next);
}
else
{
models["YtYXK"].IsError = true;
}
return(View("Screen", models["YtYXK"]));
}
public async Task <IActionResult> Index()
{
if (!await this.CheckLoginStatus())
{
return(RedirectToAction("Index", "Game", new { errorMsg = "Authorization Error" }));
}
if (Connector.GameScreenOpen)
{
await this.HubContext.Clients.All.SendAsync("NewScoreboardOpened");
}
await this.SetupGame();
if (Connector.Game == null)
{
return(RedirectToAction("Index", "Game", new { errorMsg = "No Game Currently Loaded" }));
}
if (Connector.Game.GameComplete)
{
return(RedirectToAction("Index", "Game", new { errorMsg = "Loaded game already complete." }));
}
var viewModel = new ScreenViewModel();
viewModel.Game = Connector.Game;
viewModel.HomeTeam = Connector.HomeTeam;
viewModel.AwayTeam = Connector.AwayTeam;
viewModel.GameScore = Connector.GameScore;
viewModel.League = Connector.League;
string gameTime = await SettingsUtil.GetSetting("GameTime");
if (!String.IsNullOrEmpty(gameTime))
{
viewModel.GameTime = TimeSpan.Parse(gameTime);
}
else
{
viewModel.GameTime = new TimeSpan(0, 0, 0);
}
Connector.TimerRunning = false;
Connector.MediaScreenShowing = false;
return(View(viewModel));
}
public async Task <CreateScreenResponse> Handle(CreateScreenCommand message)
{
var cinema = await _cinemaRepository.GetCinemaById(message.CinemaId);
if (cinema == null)
{
throw new InvalidOperationException($"The cinema with id [{message.CinemaId}] can not be found");
}
var screen = cinema.CreateScreen(
message.ScreenName,
message.ScreenRows,
message.ScreenSeatsPerRow);
await _unitOfWork.CommitAsync();
return(new CreateScreenResponse(ScreenViewModel.FromScreen(screen)));
}
private IDisposable BindToScreen(ScreenViewModel y)
{
CompositeDisposable screenDisposable = new CompositeDisposable();
y.Number
.BindTo(
numericUpDownScreenNumber,
z => z.Value,
BindingMode.TwoWay,
null,
z => (int)z,
Observable.FromEvent <EventHandler, EventArgs>(
h => (s, e) => h(e),
h => numericUpDownScreenNumber.ValueChanged += h,
h => numericUpDownScreenNumber.ValueChanged -= h
)
.ToUnit()
)
.AddTo(screenDisposable);
y.Number
.BindToErrorProvider(errorProvider, numericUpDownScreenNumber)
.AddTo(screenDisposable);
y.Layer
.BindTo(
numericUpDownScreenLayer,
z => z.Value,
BindingMode.TwoWay,
null,
z => (int)z,
Observable.FromEvent <EventHandler, EventArgs>(
h => (s, e) => h(e),
h => numericUpDownScreenLayer.ValueChanged += h,
h => numericUpDownScreenLayer.ValueChanged -= h
)
.ToUnit()
)
.AddTo(screenDisposable);
return(screenDisposable);
}
public ActionResult NewScreen1(Screen screen)
{
if (ModelState.IsValid)
{
var noOfScreenInTheatre = db.Theatres.Single(temp => temp.TheatreId == screen.TheatreId);
var value = noOfScreenInTheatre.NoOfScreen;
var countInScreendb = db.Screens.Count(temp => temp.TheatreId == screen.TheatreId);
if (countInScreendb >= value)
{
ViewBag.NoOfScreenExhausted = "You cannot add more screens to this theatre";
ScreenViewModel obj = new ScreenViewModel()
{
theatreList = db.Theatres.ToList()
};
return(View("NewScreen", obj));
}
else
{
db.Screens.Add(screen);
db.SaveChanges();
return(View("ScreenList", db.Screens.ToList()));
}
}
else
{
ScreenViewModel obj = new ScreenViewModel()
{
theatreList = db.Theatres.ToList(),
screen = screen
};
return(View("NewScreen", obj));
}
}
public void RoutedViewHost_Should_Show_Default_Content_When_Router_Is_Null()
{
var screen = new ScreenViewModel();
var defaultContent = new TextBlock();
var host = new RoutedViewHost
{
DefaultContent = defaultContent,
PageTransition = null,
Router = null
};
var root = new TestRoot
{
Child = host
};
Dispatcher.UIThread.RunJobs(DispatcherPriority.Loaded);
Assert.NotNull(host.Content);
Assert.Equal(defaultContent, host.Content);
host.Router = screen.Router;
Assert.NotNull(host.Content);
Assert.Equal(defaultContent, host.Content);
var first = new FirstRoutableViewModel();
screen.Router.Navigate.Execute(first).Subscribe();
Assert.NotNull(host.Content);
Assert.IsType <FirstRoutableView>(host.Content);
host.Router = null;
Assert.NotNull(host.Content);
Assert.Equal(defaultContent, host.Content);
host.Router = screen.Router;
Assert.NotNull(host.Content);
Assert.IsType <FirstRoutableView>(host.Content);
}
public async Task <Metadata> Insert(ScreenViewModel model)
{
Metadata res = new Metadata();
try
{
var data = await context.Screen.AnyAsync(x => x.screenname.ToLower().Replace(" ", "") == model.ScreenName.ToLower().Replace(" ", "") && x.screenid != model.ScreenID);
if (data)
{
return new Metadata()
{
status = false, data = "Screen name is ready"
}
}
;
await context.Screen.AddAsync(new ScreenModel()
{
screenid = model.ScreenID,
screenname = model.ScreenName,
controllername = model.ControllerName,
actionname = model.ActionName,
ismenu = model.IsMenu,
isactive = model.IsActive,
parentid = model.ParentID,
iconcss = model.IconCss
});
await context.SaveChangesAsync();
res.status = true;
res.data = "Data was successfully inserted";
}
catch (Exception ex)
{
res.status = false;
res.data = ex.Message;
}
return(res);
}
public ActionResult Edit(Guid id)
{
try
{
var screen = _screenRepository.GetById(id);
var groupList = _screenGroupRepository.List().OrderBy(x => x.Title);
var groups = new List <SelectListItem>();
foreach (var group in groupList)
{
groups.Add(new SelectListItem()
{
Value = group.Id.ToString(),
Text = group.Title
});
}
var model = new ScreenViewModel()
{
Id = screen.Id,
Title = screen.Title,
Location = screen.Location,
HostName = screen.HostName,
GroupId = screen.Group != null?screen.Group.Id.ToString() : "",
Groups = groups,
RefreshHours = screen.RefreshTime.Hours,
RefreshMinutes = screen.RefreshTime.Minutes,
RefreshSeconds = screen.RefreshTime.Seconds
};
return(View(model));
}
catch (Exception e)
{
Request.Flash("error", Resources.Resources.SevereError + ": " + e.Message);
return(RedirectToAction("Index"));
}
}
protected override async Task OnAfterRenderAsync(bool firstRender)
{
if (_loaded)
{
return;
}
_loaded = true;
_creating = NavigationManager.ToBaseRelativePath(NavigationManager.Uri).ToLowerInvariant().
StartsWith("admin/screens/create", StringComparison.InvariantCulture);
if (Id <= 0 &&
!_creating)
{
return;
}
_resolutions = await ResolutionsService.GetAsync();
_model = _creating ? new ScreenViewModel() : await Service.GetAsync(Id);
_screenResolutions = await ResolutionsByScreenService.GetByScreen(Id);
_authState = await AuthenticationStateProvider.GetAuthenticationStateAsync();
_editing = _creating || NavigationManager.ToBaseRelativePath(NavigationManager.Uri).ToLowerInvariant().
StartsWith("admin/screens/edit/",
StringComparison.InvariantCulture);
if (_editing)
{
SetCheckboxes();
}
StateHasChanged();
}
public RunFileContentViewModel(ScreenViewModel parentScreen)
: base(parentScreen)
{
Name = "From file";
Filter = "All files (*.*)|*.*";
}
