public void RemoveTransactionFromReceiptTestSeveralTransactions()
{
StorageController SC = new StorageController();
POSController POSC = new POSController(SC);
POSC.StartPurchase();
SC.ProductDictionary.TryAdd(0, new Product(1, "test1", "blabla", 1.25m, 0, false, 5.0m, 3.0m));
SC.ProductDictionary.TryAdd(1, new Product(2, "test1", "blabla", 1.25m, 0, false, 5.0m, 3.0m));
SC.ProductDictionary.TryAdd(2, new Product(3, "test1", "blabla", 1.25m, 0, false, 5.0m, 3.0m));
SaleTransaction transaction1 = new SaleTransaction(SC.ProductDictionary[0], 5, 0);
SaleTransaction transaction2 = new SaleTransaction(SC.ProductDictionary[1], 1, 0);
SaleTransaction transaction3 = new SaleTransaction(SC.ProductDictionary[2], 1, 0);
POSC.PlacerholderReceipt.Transactions.Add(transaction1);
POSC.PlacerholderReceipt.Transactions.Add(transaction2);
POSC.PlacerholderReceipt.Transactions.Add(transaction3);
bool b1 = POSC.PlacerholderReceipt.Transactions.Contains(transaction1);
bool b2 = POSC.PlacerholderReceipt.Transactions.Contains(transaction2);
bool b3 = POSC.PlacerholderReceipt.Transactions.Contains(transaction3);
POSC.RemoveTransactionFromReceipt(2);
bool b4 = POSC.PlacerholderReceipt.Transactions.Contains(transaction1);
bool b5 = !POSC.PlacerholderReceipt.Transactions.Contains(transaction2);
bool b6 = POSC.PlacerholderReceipt.Transactions.Contains(transaction3);
Assert.IsTrue(b1 && b2 && b3 && b4 && b5 && b6);
}
public async Task CreateStorageAccountTest()
{
// SET PARAMETERS
var location = Environment.GetEnvironmentVariable("AZURE_LOCATION");
var baseUriString = Environment.GetEnvironmentVariable("AZURE_BASE_URL");
var resourceGroupName = Environment.GetEnvironmentVariable("AZURE_RESOURCEGROUP");
var servicePrincipalId = Environment.GetEnvironmentVariable("AZURE_CLIENT_ID");
var servicePrincipalSecret = Environment.GetEnvironmentVariable("AZURE_CLIENT_SECRET");
var azureResourceId = Environment.GetEnvironmentVariable("AZURE_RESOURCE_ID");
var tenantId = Environment.GetEnvironmentVariable("AZURE_TENANT_ID");
var subscriptionId = Environment.GetEnvironmentVariable("AZURE_SUBSCRIPTION_ID");
var storageNamePrefix = Environment.GetEnvironmentVariable("AZURE_STORAGENAME_PREFIX");
var storageAccountName = string.Format("{0}{1}", storageNamePrefix, new Random().Next(0, 99));
var storageAccountSku = Profile2018Storage.Models.SkuName.StandardLRS;
var credentials = new CustomLoginCredentials(servicePrincipalId, servicePrincipalSecret, azureResourceId, tenantId);
// SET CONTROLLER
var resourceController = new ResourcesController(new Uri(baseUriString), credentials, subscriptionId);
var storageController = new StorageController(new Uri(baseUriString), credentials, subscriptionId);
// CREATE RESOURCE GROUP
var resourceGroup = await resourceController.CreateResourceGroup(resourceGroupName, location);
// CREATE RESOURCE GROUP VALIDATION
Assert.Equal("OK", resourceGroup.Response.ReasonPhrase, ignoreCase: true);
Assert.NotNull(resourceGroup.Body);
// CREATE STORAGE ACCOUNT
var storageAccount = await storageController.CreateStorageAccount(storageAccountName, resourceGroupName, location, storageAccountSku);
// VALIDATION
Assert.Equal("OK", storageAccount.Response.ReasonPhrase, ignoreCase: true);
Assert.NotNull(storageAccount.Body);
Assert.Equal("Succeeded", storageAccount.Body.ProvisioningState.ToString(), ignoreCase: true);
}
//Editing service product
public CreateProduct(ServiceProduct prod, StorageController storageController, bool adminEdit, bool deactivated = false)
{
Initialize(storageController);
UpdateServiceProductSec = true;
output_ProductID.Text = Product.GetNextID().ToString();
output_ServiceProductID.Text = prod.ID.ToString();
UpdateProductID = prod.ID;
FillBoxesWithExistingServiceProduct(prod);
tabControl.SelectedIndex = 1;
tabControl.Items.RemoveAt(0);
if (prod.Image != null)
{
image_ServiceProduct.Source = prod.Image.Source;
}
_isAdmin = adminEdit;
HideIfNotAdmin();
this.Title = "Rediger Service Produkt";
if (deactivated)
{
_deactivatedProd = true;
btn_disableServiceProduct.Click -= btn_disableServiceProduct_Click;
btn_disableServiceProduct.Click += btn_EnableServiceProduct_click;
btn_disableServiceProduct.Content = "Aktiver produkt";
}
}
void tileMenuItem_Click(object sender, EventArgs e)
{
try
{
App.TrackEvent("ViewMovie", "Create tile");
if (StorageController.doesFileExist(App.MovieViewModel.Imdb + "background.jpg"))
{
ImageController.copyImageToShellContent(App.MovieViewModel.Imdb + "background.jpg", App.MovieViewModel.Imdb);
FlipTileData NewTileData = new FlipTileData
{
BackgroundImage =
new Uri("isostore:/Shared/ShellContent/wptraktbg" + App.MovieViewModel.Imdb + ".jpg", UriKind.Absolute),
WideBackgroundImage =
new Uri("isostore:/Shared/ShellContent/wptraktbg" + App.MovieViewModel.Imdb + ".jpg", UriKind.Absolute),
Title = App.MovieViewModel.Name,
};
ShellTile.Create(
new Uri(
"/ViewMovie.xaml?id=" + App.MovieViewModel.Imdb,
UriKind.Relative),
NewTileData, true);
}
}
catch (InvalidOperationException) { ToastNotification.ShowToast("Tile", "Error creating tile, please try again!"); }
}
// Use this for initialization
void Start()
{
mode = 0;
y = Random.Range(-1f, -8f);
x = 0;
if (y > -4f)
{
if (Random.Range(-1, 2) > 0)
{
x = -4;
}
else
{
x = 4;
}
}
else
{
x = Random.Range(-4f, 4f);
}
this.transform.position = new Vector2(x, y);
storage = GameObject.Find("Storage");
storage2 = storage.GetComponent <StorageController>();
storageRange = storage.transform.localScale.x * 2;
graverPosition = storage.transform.position - new Vector3(Random.Range(-storageRange, storageRange), 0.3f);
}
public async void CreateRaidAsync(List <PhysicalDisk> disks, Enclousure enclousure, string level, string name, long capacity, long optimal)
{
try
{
var idrac = new StorageController(server);
IdracJob job = await idrac.CreateVirtualDiskAsync(disks, enclousure, level, capacity, optimal, name);
var load = new LoadWindow(server, job)
{
Title = server.Host
};
load.Closed += (object sender, EventArgs e) =>
{
var window = (LoadWindow)sender;
job = window.Job;
if (job.JobState.Contains("Completed"))
{
MessageBox.Show("Raid criado com sucesso !", "Sucesso", MessageBoxButton.OK, MessageBoxImage.Information);
}
};
load.Show();
}
catch (Exception ex)
{
MessageBox.Show(string.Format("Falha ao criar o Job {0}", ex.Message), "Erro", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
void tileMenuItem_Click(object sender, EventArgs e)
{
try
{
if (StorageController.doesFileExist(App.ShowViewModel.Tvdb + "background.jpg"))
{
ImageController.copyImageToShellContent(App.ShowViewModel.Tvdb + "background.jpg", App.ShowViewModel.Tvdb);
FlipTileData NewTileData = new FlipTileData
{
BackgroundImage =
new Uri("isostore:/Shared/ShellContent/wptraktbg" + App.ShowViewModel.Tvdb + ".jpg", UriKind.Absolute),
WideBackgroundImage =
new Uri("isostore:/Shared/ShellContent/wptraktbg" + App.ShowViewModel.Tvdb + ".jpg", UriKind.Absolute),
Title = App.ShowViewModel.Name,
};
if (!StorageController.doesFileExist("/Shared/ShellContent/wptraktbg" + App.ShowViewModel.Tvdb + ".jpg"))
{
NewTileData.BackgroundImage = new Uri("appdata:background.png");;
}
ShellTile.Create(
new Uri(
"/ViewShow.xaml?id=" + App.ShowViewModel.Tvdb,
UriKind.Relative),
NewTileData, true);
}
}
catch (InvalidOperationException)
{
}
}
private async void ConnectAsync(Server server)
{
if (!await NetworkHelper.CheckConnectionAsync(server.Host))
{
MessageBox.Show("Servidor inacessivel", "Erro", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
try
{
var idrac = new StorageController(server);
if (await idrac.CheckRedfishSupportAsync(StorageController.Controllers) == false)
{
MessageBox.Show(string.Format("O servidor {0} não suporta a API Redfish", server), "Aviso", MessageBoxButton.OK, MessageBoxImage.Information);
return;
}
}
catch (Exception ex)
{
MessageBox.Show(string.Format("Falha ao conectar: {0}", ex.Message), "Aviso", MessageBoxButton.OK, MessageBoxImage.Information);
return;
}
var storageWindow = new StorageWindow(server)
{
Title = server.Host
};
storageWindow.Show();
}
public void Setup()
{
options = new DbContextOptionsBuilder <AppDbContext>()
.UseInMemoryDatabase(databaseName: "Add_writes_to_database").Options;
context = new AppDbContext(options);
controller = new StorageController(context);
}
public CreateStorageRoom(StorageController stoController)
{
ControllerSto = stoController;
InitializeComponent();
SetupCreate();
btn_deleteStorageRoom.Visibility = Visibility.Hidden;
}
// Create data and category files
private async Task <bool> Initialize()
{
string assemblyPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
var dataController = new StorageController <DataModel>(Path.Combine(assemblyPath, SecureManager.DataFileName));
var dataInitializer = new StorageInitializer <DataModel>(new DataGenerator(), new Cryptographer(SecureManager.Key));
try
{
List <DataModel> dataList = await dataInitializer.GetDataAsync();
await dataController.CreateStorageAsync(dataList);
}
catch (InvalidOperationException ex)
{
MessageBox.Show($"Can't write data to {ex.Source}");
return(false);
}
var categoriesController = new StorageController <CategoryModel>(Path.Combine(assemblyPath, SecureManager.CategoriesFileName));
try
{
await categoriesController.CreateStorageAsync(new List <CategoryModel>());
}
catch (InvalidOperationException ex)
{
MessageBox.Show($"Can't write data to {ex.Source}");
return(false);
}
return(true);
}
public CreateGroup(StorageController stoController, Group groupToEdit)
{
ControllerSto = stoController;
this.groupToEdit = groupToEdit;
InitializeComponent();
SetupEdit();
}
public CreateStorageRoom(StorageController stoController, StorageRoom stoRoom)
{
ControllerSto = stoController;
storageRoomToEdit = stoRoom;
InitializeComponent();
SetupEdit();
}
//Editing normal product
public CreateProduct(Product prod, StorageController storageController, bool adminEdit, bool deactivated = false)
{
Initialize(storageController);
UpdateProductSec = true;
FillBoxesWithExistingProduct(prod);
UpdateProductID = prod.ID;
if (prod.Image != null)
{
image_Product.Source = prod.Image.Source;
}
_isAdmin = adminEdit;
tabControl.Items.RemoveAt(1);
HideIfNotAdmin();
ReloadAddedStorageRooms();
this.Title = "Rediger Produkt";
if (deactivated)
{
_deactivatedProd = true;
btn_disableProduct.Click -= btn_disableProduct_Click;
btn_disableProduct.Click += btn_EnableProduct_click;
btn_disableProduct.Content = "Aktiver produkt";
}
}
private void Initialize(StorageController storageController)
{
InitializeComponent();
_storageRooms = storageController.StorageRoomDictionary;
_storageController = storageController;
LoadStorageRooms(_storageRooms);
comboBox_Group.ItemsSource = (storageController.GroupDictionary.Values.Select(x => x.Name));
comboBox_ServiceGroup.ItemsSource = (storageController.GroupDictionary.Values.Select(x => x.Name));
comboBox_Brand.ItemsSource = (storageController.GetProductBrands());
btn_AddPicture.Click += PickImage;
btn_ServiceAddPicture.Click += PickImage;
string[] allowedImageExtensions = new string[] { ".jpg", ".bmp", ".png", ".jpeg", ".tiff", ".gif" };
ImageChosenEvent += (FilePath) =>
{
if (allowedImageExtensions.Any(x => FilePath.ToLower().Contains(x)))
{
image_Product.Source = new BitmapImage(new Uri(FilePath));
image_ServiceProduct.Source = new BitmapImage(new Uri(FilePath));
ChosenFilePath = FilePath;
}
else
{
MessageBox.Show("Ugyldig filformat!");
}
};
btn_AddStorageRoomWithAmount.Click += AddStorageWithAmount;
btn_JustQuit.Click += delegate { this.Close(); };
btn_ServiceJustQuit.Click += delegate { this.Close(); };
}
private void Start()
{
music.volume = StorageController.GetFloat(Constants.Music);
sfx.volume = StorageController.GetFloat(Constants.SFX);
musicSlider.value = StorageController.GetFloat(Constants.Music);
sfxSlider.value = StorageController.GetFloat(Constants.SFX);
}
public void Add_AddsEmployeeAndReturnsARedirect_WhenModelStateIsValid()
{
//Arrange
var mockStorageService = new Mock <IService <IRepository <Storage>, Storage> >();
mockStorageService.Setup(repo => repo.GetByIdAsync(1)).ReturnsAsync(GetStorage())
.Verifiable();
var httpContext = new DefaultHttpContext();
var tempData = new TempDataDictionary(httpContext, Mock.Of <ITempDataProvider>());
var controller = new StorageController(mockStorageService.Object)
{
TempData = tempData
};
controller.ModelState.AddModelError("Quantity", "Required");
var inputModel = new PCItemInputModel()
{
Id = 1, Quantity = 1
};
// Act
var result = controller.Add(inputModel);
// Assert
Assert.IsType <JsonResult>(result.Result);
mockStorageService.Verify();
}
private async Task DeleteVdAsync(VirtualDisk volume)
{
try
{
var idrac = new StorageController(server);
IdracJob job = await idrac.DeleteVirtualDiskAsync(volume);
var load = new LoadWindow(server, job)
{
Title = server.Host
};
load.Closed += (object sender, EventArgs e) =>
{
var window = (LoadWindow)sender;
job = window.Job;
if (job.JobState.Contains("Completed"))
{
MessageBox.Show("Volume excluido com sucesso !", "Sucesso", MessageBoxButton.OK, MessageBoxImage.Information);
}
};
load.Show();
}
catch (Exception ex)
{
MessageBox.Show(string.Format("Falha ao criar o Job {0}", ex.Message), "Erro", MessageBoxButton.OK, MessageBoxImage.Error);
}
UpdateForm();
}
public static void Main(string[] args)
{
Product NewProd = new Product(0, "mmmmmmm", "Brand", 1m, 1, false, 1m, 1m);
StorageController SC_1000 = new StorageController();
for (int i = 0; i < 1000; i++)
{
SC_1000.AllProductsDictionary.TryAdd(i, NewProd);
}
StorageController SC_10000 = new StorageController();
for (int i = 0; i < 10000; i++)
{
SC_10000.AllProductsDictionary.TryAdd(i, NewProd);
}
StorageController SC_100000 = new StorageController();
for (int i = 0; i < 100000; i++)
{
SC_100000.AllProductsDictionary.TryAdd(i, NewProd);
}
StorageController SC_1000000 = new StorageController();
for (int i = 0; i < 1000000; i++)
{
SC_1000000.AllProductsDictionary.TryAdd(i, NewProd);
}
StorageController SC_10000000 = new StorageController();
for (int i = 0; i < 10000000; i++)
{
SC_10000000.AllProductsDictionary.TryAdd(i, NewProd);
}
Group NewGroup = new Group("HAHAHAHAHAHAHAHAHA", "Test Gruppe");
SC_1000.GroupDictionary.TryAdd(1, NewGroup);
SC_10000.GroupDictionary.TryAdd(1, NewGroup);
SC_100000.GroupDictionary.TryAdd(1, NewGroup);
SC_1000000.GroupDictionary.TryAdd(1, NewGroup);
SC_10000000.GroupDictionary.TryAdd(1, NewGroup);
TestPerformance(SC_1000, "TEST");
TestPerformance(SC_10000, "TEST");
TestPerformance(SC_100000, "TEST");
TestPerformance(SC_1000000, "TEST");
TestPerformance(SC_1000, "TEST TEST");
TestPerformance(SC_10000, "TEST TEST");
TestPerformance(SC_100000, "TEST TEST");
TestPerformance(SC_1000000, "TEST TEST");
TestPerformance(SC_1000, "TEST TEST TEST");
TestPerformance(SC_10000, "TEST TEST TEST");
TestPerformance(SC_100000, "TEST TEST TEST");
TestPerformance(SC_1000000, "TEST TEST TEST");
TestPerformance(SC_1000, "TEST TEST TEST TEST");
TestPerformance(SC_10000, "TEST TEST TEST TEST");
TestPerformance(SC_100000, "TEST TEST TEST TEST");
TestPerformance(SC_1000000, "TEST TEST TEST TEST");
Console.WriteLine("DONE");
Console.ReadKey();
}
public MoveProduct(StorageController storageController, POSController posController)
{
_storageController = storageController;
_posController = posController;
InitializeComponent();
InitWindow();
this.ResizeMode = ResizeMode.NoResize;
}
public OrderTransactionWindow(StorageController storageController, POSController posController)
{
InitializeComponent();
_storageController = storageController;
_posController = posController;
this.ResizeMode = ResizeMode.NoResize;
combobox_Supplier.ItemsSource = _storageController.GetSuppliers();
}
protected override void OnApplicationPause(bool pause)
{
base.OnApplicationPause(pause);
if (pause)
{
StorageController.Save();
}
}
public CreateTemporaryProduct(StorageController storageController, POSController posController, int tempID)
{
InitializeComponent();
this.ResizeMode = ResizeMode.NoResize;
_storageController = storageController;
_posController = posController;
_tempID = tempID;
}
static void Main(string[] args)
{
libs = new StorageController();
mPub = new MessagePublisher();
libs.GetLibrary(URL);
libs.CreateBook();
mPub.MainAsync().GetAwaiter().GetResult();
}
//Creating new product
public CreateProduct(StorageController storageController)
{
Initialize(storageController);
output_ProductID.Text = Product.GetNextID().ToString();
output_ServiceProductID.Text = ServiceProduct.GetNextID().ToString();
btn_disableProduct.Visibility = Visibility.Hidden;
btn_disableServiceProduct.Visibility = Visibility.Hidden;
this.Title = "Opret Produkt";
}
public async Task Removing_an_item_Should_return_no_content_result_If_successful()
{
var contextWithData = CreateContextWithData(1);
var controller = new StorageController(new DataRepository(contextWithData));
var result = await controller.RemoveItemAmount("Ost", 1) as NoContentResult;
Assert.AreEqual(204, result?.StatusCode);
await contextWithData.Database.EnsureDeletedAsync();
}
public async Task Getting_item_count_Should_return_not_found_result_If_item_does_not_exist()
{
var contextWithData = CreateContextWithData(1);
var controller = new StorageController(new DataRepository(contextWithData));
var result = await controller.GetItemCount("Does Not Exist") as NotFoundObjectResult;
Assert.AreEqual(404, result?.StatusCode);
await contextWithData.Database.EnsureDeletedAsync();
}
public async Task Removing_an_item_Should_return_not_found_result_If_no_matching_item_exist()
{
var contextWithData = CreateContextWithData(1);
var controller = new StorageController(new DataRepository(contextWithData));
var result = await controller.RemoveItemAmount("Does not exist", 5) as NotFoundObjectResult;
Assert.AreEqual(404, result?.StatusCode);
await contextWithData.Database.EnsureDeletedAsync();
}
public async Task Removing_an_item_Should_return_bad_request_result_If_removing_more_items_than_is_available()
{
var contextWithData = CreateContextWithData(1);
var controller = new StorageController(new DataRepository(contextWithData));
var result = await controller.RemoveItemAmount("Ost", 5) as BadRequestObjectResult;
Assert.AreEqual(400, result?.StatusCode);
await contextWithData.Database.EnsureDeletedAsync();
}
/// <summary>
/// Clears the chatSelectionStack
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void DebugClear_Clicked(object sender, EventArgs e)
{
StorageController.SaveData(new List <Chat>());
Device.BeginInvokeOnMainThread(() =>
{
chatSelectionStack.Children.Clear();
});
}
IEnumerator TestTableRefAsync()
{
Terminal.LogImportant("TestTableRefAsync");
if (Context != null)
{
if (Context.IsConnected)
Context.Disconnect();
yield return 1;
}
// Construct
Context = new StorageController(AuthKey);
// Wait for Connect
yield return StartCoroutine(Context.WaitForConnect());
// get score table
var tableTask = Context.Table<Score>();
yield return StartCoroutine(tableTask.WaitRoutine());
tableTask.ThrowIfFaulted();
var table = tableTask.Result;
//Wire listeners
int callbacks = 0;
table.On(StorageEventType.DELETE, response =>
{
Terminal.Log("DELETE " + response.Val<Score>().UserName);
callbacks++;
});
table.On(StorageEventType.PUT, response =>
{
Terminal.Log("PUT " + response.Val<Score>().UserName);
callbacks++;
});
table.On(StorageEventType.UPDATE, response =>
{
Terminal.Log("UPDATE " + response.Val<Score>().UserName);
callbacks++;
});
//test
var score = new Score
{
Points = Strings.RandomNumber(100, 10000),
Points2 = Strings.RandomNumber(100, 10000),
UserName = Strings.RandomString(10),
};
var tresult1 = Context.Repository.Create(score);
yield return StartCoroutine(tresult1.WaitRoutine());
tresult1.ThrowIfFaulted();
var tresult2 = Context.Repository.Update(score);
yield return StartCoroutine(tresult2.WaitRoutine());
tresult2.ThrowIfFaulted();
var tresult3 = Context.Repository.Delete(score);
yield return StartCoroutine(tresult3.WaitRoutine());
tresult3.ThrowIfFaulted();
Terminal.Log("Updates posted. Waiting for response");
for (int i = 0;i < 10;i++)
{
if (callbacks >= 3)
break;
yield return new WaitForSeconds(2.5f);
Terminal.Log(".");
}
if (callbacks < 3)
Debug.LogWarning("Failed to get all update messages. This sometimes happens, please try again.");
else
Terminal.LogSuccess("Test Success");
}
