public ActionResult PasscodeView(ViewModelData viewModelData)
{
if (ModelState.IsValid)
{
try
{
if (viewModelData.simple_String == "1212")
{
if (viewModelData.menu_String == "0")
{
return(RedirectToAction("AddOwnerView", "Owner"));
}
else
{
return(RedirectToAction("AddAdminView", "Account"));
}
}
}
catch (Exception ex)
{
//Add error
ViewBag.Message = ex;
return(View(viewModelData));
}
}
ViewBag.Message = "Missing Passcode";
return(View(viewModelData));
}
protected virtual ViewModel CreateViewModel(MappingData mappingData)
{
ViewModelData viewModelData = mappingData.SourceViewModel;
EntityModelData entityModelData = viewModelData as EntityModelData;
ViewModel result;
if (string.IsNullOrEmpty(mappingData.ModelId))
{
// Use parameterless constructor
result = (ViewModel)mappingData.ModelType.CreateInstance();
}
else
{
// Pass model Identifier in constructor.
result = (ViewModel)mappingData.ModelType.CreateInstance(mappingData.ModelId);
}
result.ExtensionData = viewModelData.ExtensionData;
result.HtmlClasses = viewModelData.HtmlClasses;
result.XpmMetadata = mappingData.Localization.IsXpmEnabled ? viewModelData.XpmMetadata : null;
MediaItem mediaItem = result as MediaItem;
if (mediaItem != null)
{
BinaryContentData binaryContent = entityModelData?.BinaryContent;
if (binaryContent == null)
{
throw new DxaException(
$"Unable to create Media Item ('{mappingData.ModelType.Name}') because the Data Model '{entityModelData?.Id}' does not contain Binary Content Data."
);
}
mediaItem.Url = binaryContent.Url;
mediaItem.FileName = binaryContent.FileName;
mediaItem.MimeType = binaryContent.MimeType;
mediaItem.FileSize = binaryContent.FileSize;
}
EclItem eclItem = result as EclItem;
if (eclItem != null)
{
ExternalContentData externalContent = entityModelData.ExternalContent;
if (externalContent == null)
{
throw new DxaException(
$"Unable to create ECL Item ('{mappingData.ModelType.Name}') because the Data Model '{entityModelData.Id}' does not contain External Content Data."
);
}
eclItem.EclDisplayTypeId = externalContent.DisplayTypeId;
eclItem.EclTemplateFragment = externalContent.TemplateFragment;
eclItem.EclExternalMetadata = externalContent.Metadata;
eclItem.EclUri = externalContent.Id;
}
MapSemanticProperties(result, mappingData);
return(result);
}
public void BuildEntityModel(ref EntityModelData entityModelData, Component component, ComponentTemplate ct,
bool includeComponentTemplateDetails, int expandLinkDepth)
{
Logger.Debug("Adding folder metadata to entity model metadata.");
Folder folder = (Folder)component.OrganizationalItem;
List <string> schemaIdList = new List <string>();
// Checking for Schema Metadata is very important because we need to stop adding metadata as soon as we found folder without it
while (folder != null && folder.MetadataSchema != null)
{
if (folder.Metadata != null)
{
schemaIdList.Insert(0, new TcmUri(folder.MetadataSchema.Id).ItemId.ToString());
ContentModelData metaData = BuildContentModel(folder.Metadata, expandLinkDepth);
string[] duplicateFieldNames;
ContentModelData emdMetadata = entityModelData.Metadata ?? new ContentModelData();
entityModelData.Metadata = MergeFields(emdMetadata, metaData, out duplicateFieldNames);
}
folder = (Folder)folder.OrganizationalItem;
}
ViewModelData vm = entityModelData as ViewModelData;
if (schemaIdList.Count > 0)
{
CreateSchemaIdListExtensionData(ref vm, schemaIdList);
}
}
public ActionResult PasscodeView(string menu)
{
ViewModelData viewModelData = new ViewModelData();
viewModelData.menu_String = menu;
return(View(viewModelData));
}
public MainWindow()
{
InitializeComponent();
_vm_data = new ViewModelData();
this.DataContext = _vm_data;
}
public ActionResult AddOwnerView(ViewModelData viewModelData)
{
if (ModelState.IsValid)
{
try
{
OwnerAccount newAccount = viewModelData.owner;
if (!ownerRepository.CheckOwner(newAccount))
{
ownerRepository.Add(newAccount);
return(GoToMainOwnerView(newAccount.Id));
}
}
catch (Exception ex)
{
//Add error
ViewBag.Message = ex;
return(View(viewModelData));
}
}
ViewBag.Message = "Missing or Incorrect Data";
return(View(viewModelData));
}
public void BuildPageModel(ref PageModelData pageModelData, Page page)
{
Logger.Debug("Adding structure group metadata to page model metadata.");
StructureGroup structureGroup = (StructureGroup)page.OrganizationalItem;
List <string> schemaIdList = new List <string>();
// Checking for Schema Metadata is very important because we need to stop adding metadata as soon as we found page without it
while (structureGroup != null && structureGroup.MetadataSchema != null)
{
schemaIdList.Insert(0, new TcmUri(structureGroup.MetadataSchema.Id).ItemId.ToString());
if (structureGroup.Metadata != null)
{
ContentModelData metaData = BuildContentModel(structureGroup.Metadata, Pipeline.Settings.ExpandLinkDepth);
string[] duplicateFieldNames;
ContentModelData pmdMetadata = pageModelData.Metadata ?? new ContentModelData();
pageModelData.Metadata = MergeFields(pmdMetadata, metaData, out duplicateFieldNames);
}
structureGroup = structureGroup.OrganizationalItem as StructureGroup;
}
ViewModelData vm = pageModelData as ViewModelData;
CreateSchemaIdListExtensionData(ref vm, schemaIdList);
}
public ExportableDataGenerator(ViewModelData <T, N> method, ILogger logger = null)
{
_totalRecords = 0;
_pageNumber = 1;
Method = method;
_logger = logger;
}
public ActionResult AddAdminView(ViewModelData viewModelData)
{
if (ModelState.IsValid)
{
try
{
Account newAccount = viewModelData.Account;
if (!accountRepository.CheckAccount(newAccount))
{
accountRepository.Add(newAccount);
Message message = new Message
{
Subject = "Account Created",
Recepient = newAccount.UserEmail,
Body = "A brand new Keiki Admin account was created with your email. If this was not you, please contact this number 000-000-0000"
};
EmailData emailData = new EmailData(message);
return(GoToMainRecordView(newAccount.Id));
}
}
catch (Exception ex)
{
//Add error
ViewBag.Message = ex;
return(View(viewModelData));
}
}
ViewBag.Message = "Missing or Incorrect Data";
return(View(viewModelData));
}
public ActionResult StorePageView(int id, string searchData, string specialItems, bool hadError)
{
ViewModelData viewModelData = new ViewModelData(id);
List <string> names = new List <string>
{
"leifheanzo",
"snatti89",
"unpreti",
"nixeu",
"wlop",
"talros",
"razaras"
};
viewModelData.SimpleList = names;
IEnumerable <Item> items = specialItems == null?itemRepository.GetItems() : itemRepository.GetSpecialItems();
viewModelData.Items = items;
//Check if search exists and try getting the data
if (searchData != null)
{
try
{
JToken data;
client = new APIServiceClient();
if (!searchData.Contains("by"))
{
JObject json = JObject.Parse(GetDataAsync(searchData, 0).Result);
data = json["results"];
viewModelData.ItemsSimple1 = data;
}
else
{
//Get the data from the service using API Beta
JObject jsonDataVal = JObject.Parse(GetDataAsync(searchData, 1).Result);
data = jsonDataVal["rss"]["channel"]["item"];
viewModelData.ItemsSimple2 = data;
}
client.CloseAsync();
}
catch
{
ViewBag.msg = "Sorry, there was an Error. The Webservice could be down.";
}
}
if (hadError)
{
ViewBag.Message = "An error occured. Try again.";
}
return(View(viewModelData));
}
public ActionResult CreditCardView(int id, int itemId)
{
ViewModelData viewModelData = new ViewModelData(id);
viewModelData.ItemId = itemId;
return(View(viewModelData));
}
private static void AssertEqualViewModels(ViewModelData expected, ViewModelData actual, string subject)
{
Assert.AreEqual(expected.MvcData, actual.MvcData, subject + ".MvcData");
Assert.AreEqual(expected.HtmlClasses, actual.HtmlClasses, subject + ".HtmlClasses");
AssertEqualDictionaries(expected.XpmMetadata, actual.XpmMetadata, subject + ".XpmMetadata");
AssertEqualDictionaries(expected.ExtensionData, actual.ExtensionData, subject + ".ExtensionData");
Assert.AreEqual(expected.SchemaId, actual.SchemaId, subject + ".SchemaId");
// TODO: AssertEqualDictionaries(expected.Metadata, actual.Metadata, subject + ".Metadata");
}
/// <summary>
/// Lanza el evento <see cref="SelectedPathChangedEvent"/>
/// </summary>
private void RaiseSelectedPathEvent()
{
FtpFileNodeViewModel objFile = ViewModelData?.GetSelectedFile();
if (objFile?.IsFolder ?? false)
{
SelectedPath = objFile.File;
RaiseEvent(new RoutedEventArgs(SelectedPathChangedEvent));
}
}
// GET: VipTicket
public ViewResult Index()
{
var vipTickets = _context.VipTickets.OrderByDescending(v => v.Id).ToList();
var viewResult = new ViewModelData
{
VipTickets = vipTickets
};
return(View(viewResult));
}
public ActionResult ChildReportView(ViewModelData viewModelData)
{
try
{
EmailData emailData = new EmailData(viewModelData.message);
return(GoToChildList(viewModelData.AccountId));
}
catch {
return(RedirectToAction("ChildReportView", "Item", new { id = viewModelData.AccountId, childId = viewModelData.Child.Id }));
}
}
public ActionResult AddTeacherView(int id)
{
try
{
ViewModelData viewModelData = new ViewModelData(id);
viewModelData.Account = accountRepository.GetAnAccount(id);
return(View(viewModelData));
}
catch
{
return(GoToTeacherList(id));
}
}
public ActionResult DeleteAccountView(int id)
{
try
{
ViewModelData viewModelData = new ViewModelData(id);
viewModelData.Account = accountRepository.GetAnAccount(id);
return(View(viewModelData));
}
catch
{
return(GoToMainRecordView(id));
}
}
public ActionResult DeleteChildView(int id, int childId)
{
try
{
ViewModelData viewModelData = new ViewModelData(id);
viewModelData.Account = accountRepository.GetAnAccount(id);
viewModelData.Child = childRepository.GetAChild(childId);
return(View(viewModelData));
}
catch
{
return(GoToChildList(id));
}
}
public ActionResult ConfirmView()
{
//If card exists, perform action
if (TempData["ViewModelData"] != null)
{
ViewModelData viewModelData = JsonConvert.DeserializeObject <ViewModelData>((string)TempData["ViewModelData"]);
viewModelData.OrderCartId = ordersCartRepository.GetAnOrdersCart(viewModelData.AccountId).Id;
viewModelData.Item = itemRepository.GetAnItem(viewModelData.Card.ItemId);
return(View(viewModelData));
}
else
{
return(RedirectToAction("StorePageView", "Item"));
}
}
public ActionResult OwnerMainView(int id)
{
ViewModelData viewModelData = new ViewModelData(id);
viewModelData.AccountId = id;
IEnumerable <Account> accounts = accountRepository.GetAccounts();
viewModelData.Accounts = accounts;
IEnumerable <Child> children = childRepository.GetChildren();
viewModelData.Children = children;
return(View(viewModelData));
}
public ActionResult ShoppingCartView(int id)
{
try
{
ViewModelData viewModelData = new ViewModelData(id);
ShoppingCart shoppingCart = shoppingCartRepository.GetAShoppingCart(id);
viewModelData.ShoppingCartItems = shoppingCartRepository.GetSavedItems(shoppingCart.Id);
return(View(viewModelData));
}
catch
{
return(RedirectToAction("StorePageView", "Item", new { id, errorMessage = true }));
}
}
public ActionResult OrderCartView(int id)
{
try
{
ViewModelData viewModelData = new ViewModelData(id);
OrdersCart ordersCart = ordersCartRepository.GetAnOrdersCart(id);
viewModelData.Orders = ordersCartRepository.GetOrders(ordersCart.Id);
return(View(viewModelData));
}
catch
{
return(RedirectToAction("StorePageView", "Item", new { id, errorMessage = true }));
}
}
public ActionResult ConfirmViewPost(ViewModelData viewModelData)
{
if (ModelState.IsValid)
{
ordersCartRepository.AddOrder(viewModelData.Order);
//If card is special, send an email
if (viewModelData.CardType == 1)
{
EmailData emailData = new EmailData();
emailData.SendMail(accountRepository.GetAnAccount(viewModelData.AccountId).UserEmail);
}
return(RedirectToAction("StorePageView", "Item", new { id = viewModelData.AccountId }));
}
return(View());
}
public CollectionViewPage()
{
InitializeComponent();
this.BindingContext = viewModel = new ViewModelData();
//Simulating the events from SignalR
Xamarin.Forms.Device.StartTimer(TimeSpan.FromSeconds(10), () =>
{
var rowToRemove = rd.Next(0, 10);
viewModel.ObjectBindables.RemoveAt(rowToRemove);
var indexToAdd = rd.Next(0, 10);
var rowToAdd = rd.Next(11, 99);
viewModel.ObjectBindables.Insert(indexToAdd, viewModel.ReadOnlyData[rowToAdd]);
return(timeEnabled);
});
}
private Mock <DebugPageViewModel> CreateViewModel(ViewModelData data)
{
// Setup the debug profiles
var mockSourceBlock = new Mock <IReceivableSourceBlock <ILaunchSettings> >();
var mockProfiles = new Mock <ILaunchSettings>();
var unconfiguredProject = UnconfiguredProjectFactory.Create(filePath: @"C:\Foo\foo.proj");
data.FirstSnapshotComplete = new TaskCompletionSource <bool>();
var viewModel = new Mock <DebugPageViewModel>(data.FirstSnapshotComplete, unconfiguredProject);
mockSourceBlock.Setup(m => m.LinkTo(It.IsAny <ITargetBlock <ILaunchSettings> >(), It.IsAny <DataflowLinkOptions>())).Callback
(
(ITargetBlock <ILaunchSettings> targetBlock, DataflowLinkOptions options) =>
{
targetBlock.Post(mockProfiles.Object);
targetBlock.Complete();
}
).Returns(() => null);
mockProfiles.Setup(m => m.Profiles).Returns(() =>
{
return(data.Profiles?.ToImmutableList());
});
data.LaunchProfiles = mockProfiles.Object;
var mockProfileProvider = new Mock <ILaunchSettingsProvider>();
mockProfileProvider.SetupGet(m => m.SourceBlock).Returns(mockSourceBlock.Object);
mockProfileProvider.SetupGet(m => m.CurrentSnapshot).Returns(data.LaunchProfiles);
mockProfileProvider.Setup(m => m.UpdateAndSaveSettingsAsync(It.IsAny <ILaunchSettings>())).Callback((ILaunchSettings newProfiles) =>
{
data.Profiles = new List <ILaunchProfile>(newProfiles.Profiles);
}
).Returns(Task.Run(() => { })).Verifiable();
data.ProfileProvider = mockProfileProvider.Object;
viewModel.CallBase = true;
viewModel.Protected().Setup <ILaunchSettingsProvider>("GetDebugProfileProvider").Returns(mockProfileProvider.Object);
viewModel.Protected().Setup <IEnumerable <Lazy <ILaunchSettingsUIProvider, IOrderPrecedenceMetadataView> > >("GetUIProviders").Returns(data.UIProviders);
return(viewModel);
}
public ActionResult SaveItemView(ViewModelData viewModelData)
{
if (ModelState.IsValid)
{
ShoppingCart shoppingCart = shoppingCartRepository.GetAShoppingCart(viewModelData.AccountId);
Item item = itemRepository.GetAnItem(viewModelData.ItemId);
ShoppingCartItem shoppingCartItem = new ShoppingCartItem
{
ItemId = item.Id,
ItemURL = item.ItemURL,
Price = item.ItemPrice,
ShoppingCartId = shoppingCart.Id
};
shoppingCartRepository.AddShoppingCartItem(shoppingCartItem);
return(RedirectToAction("StorePageView", "Item", new { id = viewModelData.AccountId }));
}
return(View());
}
private void trvExplorer_Drop(object sender, DragEventArgs e)
{
FtpFileNodeViewModel objNodeSource = objDragDropController.GetDragDropFileNode(e.Data) as FtpFileNodeViewModel;
if (objNodeSource != null)
{
TreeViewItem trvNode = new Libraries.MVVM.Tools.ToolsWpf().FindAncestor <TreeViewItem>((DependencyObject)e.OriginalSource);
if (trvNode != null)
{
FtpFileNodeViewModel objNodeTarget = trvNode.Header as FtpFileNodeViewModel;
if (objNodeSource != null && objNodeTarget != null)
{
ViewModelData.Copy(objNodeSource, objNodeTarget,
(e.KeyStates & DragDropKeyStates.ControlKey) == DragDropKeyStates.ControlKey);
}
}
}
}
public ActionResult DeleteChildView(ViewModelData viewModelData)
{
if (ModelState.IsValid)
{
try
{
childRepository.Delete(childRepository.GetAChild(viewModelData.Child.Id));
return(GoToChildList(viewModelData.AccountId));
}
catch (Exception ex)
{
//Add error
ViewBag.Message = ex;
return(View(viewModelData));
}
}
ViewBag.Message = "Missing or Incorrect Data";
return(View());
}
public ActionResult EditTeacherView(ViewModelData viewModelData)
{
if (ModelState.IsValid)
{
try
{
accountRepository.Update(viewModelData.Teacher);
return(GoToTeacherList(viewModelData.AccountId));
}
catch (Exception ex)
{
//Add error
ViewBag.Message = ex;
return(View(viewModelData));
}
}
ViewBag.Message = "Missing or Incorrect Data";
return(View(viewModelData));
}
public async Task DebugPageViewModel_PropertyChange()
{
var unconfiguredProvider = new TestUnconfiguredPropertyProvider();
var profiles = new List <ILaunchProfile>()
{
{ new LaunchProfile()
{
Name = "p1", CommandName = "test", DoNotPersist = true
} }
};
var viewModelData = new ViewModelData()
{
UnconfiguredProvider = unconfiguredProvider,
Profiles = profiles,
UIProviders = new List <Lazy <ILaunchSettingsUIProvider, IOrderPrecedenceMetadataView> >()
{
{ new Lazy <ILaunchSettingsUIProvider, IOrderPrecedenceMetadataView>(() =>
{
var uiProvider = new Mock <ILaunchSettingsUIProvider>();
uiProvider.Setup(m => m.CustomUI).Returns((UserControl)null);
uiProvider.Setup(m => m.ShouldEnableProperty(It.IsAny <string>())).Returns(true);
uiProvider.Setup(m => m.CommandName).Returns("test");
return(uiProvider.Object);
}, new Mock <IOrderPrecedenceMetadataView>().Object) }
}
};
var viewModel = CreateViewModel(viewModelData);
await viewModel.Object.Initialize();
await viewModelData.FirstSnapshotComplete.Task;
Assert.True(viewModel.Object.HasProfiles);
Assert.True(viewModel.Object.IsProfileSelected);
Assert.True(viewModel.Object.SelectedDebugProfile.IsInMemoryObject());
// Change a property, should trigger the selected profile to no longer be in-memory
viewModel.Object.CommandLineArguments = "-arg";
Assert.False(viewModel.Object.SelectedDebugProfile.IsInMemoryObject());
}
