public static async Task WorkingWithCombinedAlerts()
        {
            DbContextOptionsBuilder <ManufacturingContext> optionsBuilder = new DbContextOptionsBuilder <ManufacturingContext>();

            optionsBuilder.UseSqlServer("server=172.27.192.1;database=manufacturing_inventory;user=aelmendorf;password=Drizzle123!;MultipleActiveResultSets=true");
            using var context = new ManufacturingContext(optionsBuilder.Options);

            var user = context.Users
                       .Include(e => e.Sessions)
                       .ThenInclude(e => e.Transactions)
                       .Include(e => e.Permission)
                       .FirstOrDefault(e => e.FirstName == "Andrew");
            UserService userService = new UserService();

            if (user != null)
            {
                Session session = new Session(user);
                await context.Sessions.AddAsync(session);

                await context.SaveChangesAsync();

                userService.CurrentUserName    = user.UserName;
                userService.CurrentSessionId   = session.Id;
                userService.UserPermissionName = user.Permission.Name;
            }
            var stockType = await context.Categories.OfType <StockType>().Include(e => e.PartInstances).ThenInclude(e => e.BubblerParameter).FirstOrDefaultAsync(e => e.Id == 16);

            if (stockType != null)
            {
                CombinedAlert tmaAlert  = new CombinedAlert();
                UserAlert     userAlert = new UserAlert();
                userAlert.IsEnabled  = true;
                tmaAlert.StockHolder = stockType;
                userAlert.Alert      = tmaAlert;
                userAlert.User       = user;
                var added = await context.AddAsync(userAlert);

                if (added != null)
                {
                    await context.SaveChangesAsync();

                    Console.WriteLine("Should be saved");
                }
                else
                {
                    Console.WriteLine("Could Not Save UserAlert");
                }
            }
            else
            {
                Console.WriteLine("StockType is null");
            }
        }
        public static void AddAlertToAllInstances()
        {
            DbContextOptionsBuilder <ManufacturingContext> optionsBuilder = new DbContextOptionsBuilder <ManufacturingContext>();

            optionsBuilder.UseSqlServer("server=192.168.0.5;database=manufacturing_inventory_dev;user=aelmendorf;password=Drizzle123!;MultipleActiveResultSets=true");
            using var context = new ManufacturingContext(optionsBuilder.Options);
            var user = context.Users
                       .Include(e => e.Sessions)
                       .ThenInclude(e => e.Transactions)
                       .Include(e => e.Permission)
                       .FirstOrDefault(e => e.FirstName == "Andrew");
            UserService userService = new UserService();

            if (user != null)
            {
                Session session = new Session(user);
                context.Sessions.Add(session);
                context.SaveChanges();
                userService.CurrentUserName    = user.UserName;
                userService.CurrentSessionId   = session.Id;
                userService.UserPermissionName = user.Permission.Name;
            }
            var         partInstances = context.PartInstances.Include(e => e.IndividualAlert).Include(e => e.StockType).ThenInclude(e => e.CombinedAlert);
            List <Task> tasks         = new List <Task>();

            foreach (var instance in partInstances)
            {
                if (instance.StockType.IsDefault)
                {
                    //individual alert
                    if (instance.IndividualAlert == null)
                    {
                        Console.WriteLine("Individual Alert, PartInstance: {0}", instance.Name);
                        IndividualAlert alert = new IndividualAlert();
                        alert.PartInstance       = instance;
                        instance.IndividualAlert = alert;
                        context.Add(alert);
                    }
                }
                else
                {
                    //combined alert
                    if (instance.StockType.CombinedAlert == null)
                    {
                        Console.WriteLine("Combined Alert, StockType: {0}", instance.StockType.Name);
                        CombinedAlert alert = new CombinedAlert();
                        alert.StockHolder = instance.StockType;
                        context.Add(alert);
                    }
                }
            }
            context.SaveChanges();
        }
        public async Task <CategoryBoundaryOutput> ExecuteAdd(CategoryBoundaryInput input)
        {
            var category = input.Category.GetCategory();

            if (category == null)
            {
                return(new CategoryBoundaryOutput(null, false, "Internal Error: Could not Cast to Specified Category, Please Contact Admin"));
            }

            if (input.Category.Type == CategoryTypes.StockType && input.Category.IsDefault)
            {
                return(new CategoryBoundaryOutput(null, false, "Error: Cannot change default StockType"));
            }

            if (input.IsDefault_Changed)
            {
                await this.ClearCategoryDefault(input.Category.Type);
            }

            if (input.Category.Type == CategoryTypes.StockType)
            {
                CombinedAlert combinedAlert = new CombinedAlert();
                combinedAlert.StockHolder = category as StockType;
                this._context.Add(combinedAlert);
            }

            var added = await this._categoryRepository.AddAsync(category);

            if (added != null)
            {
                var count = await this._unitOfWork.Save();

                if (count > 0)
                {
                    return(new CategoryBoundaryOutput(category, true, "Success: Category Added"));
                }
                else
                {
                    await this._unitOfWork.Undo();

                    return(new CategoryBoundaryOutput(null, false, "Error:  Failed to Add new Category"));
                }
            }
            else
            {
                await this._unitOfWork.Undo();

                return(new CategoryBoundaryOutput(null, false, "Error:  Failed to Add new Category"));
            }
        }