Asp.Net Core 5.0 & Vue JS From Zero to Hero 68 Hours Content

Install Visual Studio Code on Windows, Mac, or Linux, set up the Live Server extension, and learn to run and create bluejays applications.

Learn to build a simple Vue.js app in Visual Studio Code, define a message variable, and display it using text interpolation and a basic function.

Learn how to access variables inside a Vue data block using this, including combining message and description with plus operators to render in the view.

Learn how to bind urls in Vue.js using v-bind for attributes like href and src, including using interpolation and rebind syntax, to create dynamic links.

Explore how the v-once directive in Vue.js renders a value once and prevents further changes, while a separate function can update other aspects of the display.

learn how to use the v-html directive in Vue to render a dynamic html string by binding a variable, creating links and buttons.

Learn to use the v-on event listener in Vue.js by wiring click events, using the shorthand @click, and passing arguments to handler functions.

Learn how to listen for click events and stop them from firing. Use a shorthand stop on click and prevent the alert message from appearing.

Explore keyboard events such as key up and on enter by wiring handlers, display the input value, and trigger alerts based on pressed keys using event targets.

Learn how to implement two-way binding with an input and a data model, so changes to the input update the bound value and the displayed text in real time.

Discover how computed properties prevent repeating yourself by turning repeated calculations into a single property, demonstrated with two counters and console logs that only react to the clicked button.

Learn how to use the watch property to observe and react to data changes, using input examples and console logging of old and new values.

Learn how to use if, else, and else if conditions to control display and flow in your app, including comparisons, boolean toggling, and handling not equals logic.

This lecture demonstrates using v-show to toggle a boolean and hide content with display none, comparing it to if/else and showing that v-show hides without removing the element.

Learn to use a for loop to iterate over a simple list of languages. Display items with string interpolation and understand zero-based indices.

Learn to loop over a list of objects and display each person’s name and h with for loops, indexing, and interpolation.

Learn how to create a new ASP.NET Core web project in Visual Studio, enable Razor runtime compilation, install the necessary package, configure startup, and run and modify Razor templates live.

Learn to import and apply template files from a phantom folder, copy assets (fonts, images, JavaScript) into your project, and unify the header and layout across pages.

Explore creating and reusing template files for the home page, updating assets with tilde path syntax, and building multiple header variations with partials to render a professional layout.

In this lesson, we create a new database manually and build two tables: admin users and category, including fields like id, username, password, category name, slug, and order.

Create database tables for comments, cities, and articles; define fields like id, user name, email, comment text, created and modified dates, and a publish status.

Learn to create the article table in the database with a secure 32-character ID, category reference, author details, content, publishing and modified dates, and various flags and counters.

Create a comment entity to map to its database table, set up an entities folder, and define properties like id, article id, name, email, create date, modified date, and status.

Create city, admin, category entities in asp.net core 5.0 with vue js. Define city id and name, admin id with username and password, category id with name and order.

Create the article entity with id, category id, title, image, author details, content, and date fields, then set up the database connection for future models and controllers.

Learn to create a default connection string to connect to the Deeper Phantom database using dapper and dapper cantrip, install the packages, and configure server, database, and trusted connection settings.

Create a connection service using Microsoft.Extensions.Configuration to obtain a default and an additional connection string, then open and manage the connections programmatically.

Create a category service that retrieves all categories using internet or deeper connections, wired through configuration and using Dapper, mapping category id, name, slug, and order.

Learn to display categories by creating a category model, integrating a category service, and rendering all categories in the home index view.

Display category names in the index template by looping the category list from the model, binding each name, and wiring the category service in startup.

Learn to create a new article by building an article controller and a create article template, including a multi-field post form integrated with the layout.

Create an add article form by duplicating inputs for name, email, title, and content. Add category and city selects and prepare database-bound options for future retrieval.

Learn to display categories in a template by creating a category service, retrieving all categories, and binding them to a view with a model.

Build and wire a city service to the app, fetch cities, and display them in the template as city names and ids, with image upload and submit buttons.

Create an image upload button alongside a submit button, configure a file input, and implement a secure upload flow with JavaScript and an async script section in the layout.

Build a JavaScript upload function that restricts uploads to images, reads the file, validates extensions, and alerts on non-image files, with a nod to data annotations for forms.

Apply data annotations in asp.net core forms to enforce required fields and customize error messages. Explore validating category, city, title, name, email, and content in article submission.

Learn to display data annotations in templates by wiring asp-validation-for and validation-summary, enable jquery unobtrusive validation, and show field-specific and summary error messages for a form.

Implement a post action using IActionResult to save a new article in an ASP.NET Core app, including form binding, model state validation, and image upload handling.

Learn to upload images in an ASP.NET Core 5.0 and Vue.js project by creating an uploads folder and an upload helper. Configure hosting environment to store images.

Learn to implement an image upload function in an ASP.NET Core and Vue.js project, using an async method with IFormFile and an upload helper to store images.

Create an article service to save articles in the database using a private connection and configuration, then wire it to the article controller to insert articles and return the result.

Learn to create a new article in asp.net core 5 using the article service, handling safe actions, startup wiring, and checking the model is valid before redirecting.

Learn how to implement an article get-by-id function in asp.net core 5 and vue js, including fetching a single article via a service, antiforgery token validation, and rendering detail page.

Learn to build an article detail template in ASP.NET Core by wiring a single article model to a detail view, reuse the layout, and display the image, title, and content.

Learn to use a GUID string value for the article detail page, replacing integer IDs, by updating the article service, routes, and controllers in ASP.NET Core 5.0 with Vue.js.

Create an admin directory using areas in asp.net core, organizing controllers, data models, and views, and build a shared layout with header and partials for the admin area.

Create an admin service in ASP.NET Core 5.0 that wires configuration, establishes a database connection via a connection service, and implements a login function for admins.

Create a login controller in asp.net core, wire an admin service with dependency injection, and fix routing conflicts between home controllers while returning a model for login.

Create a functional login form in an asp.net core 5.0 and Vue.js project, wiring username and password inputs and post methods with data annotations.

Apply data annotations to a login form, customize required and length validation, display targeted error messages, and enable client-side validation with the necessary scripts.

Explore how to implement a login flow with ASP.NET Core 5.0, handling post login, validating credentials, issuing cookies for user id and username, managing errors, and redirecting to home index.

Demonstrate creating a user login dependency injection class in asp.net core 5, using an action executed filter to validate cookies and enforce admin login across controllers.

Learn to build an admin header and navigation bar with bootstrap 5 for an ASP.NET Core project, wiring links for home, users, categories, articles (pending, approved, rejected), and logout.

Learn to implement an admin navigation bar in Asp.Net Core by conditionally rendering the header partial based on login state and adjusting the layout to show the navbar after login.

Create and display a user model and user controller in an ASP.NET Core project, wiring up an admin service and dependency injection to return a list of users.

Create a get all function in the admin service to fetch all users and render them in a template table showing id, username, and password with edit and delete actions.

Learn to create a new user in the admin area by implementing a get and post action in the user controller, with a validated form using anti-forgery tokens.

Create a user add form in an ASP.NET Core app, using data annotations for validation, posting to a controller action, and saving the new user to the database.

Create a new user using data annotations for validation, an admin service insert function, and error handling to return user id and refresh the user list.

Learn to implement a user update flow in asp.net core 5.0 by building get and post edit actions, wiring up admin service calls, and retrieving a user by id.

Create an http post update for users by adding an admin service update function, using antifragile validation on a form, and updating username and password via dynamic parameters.

Learn to implement a user deletion workflow with a dangerous delete button, a controller get/post, and a service deleting by id, with form validation, token handling, and a confirmation dialog.

Create an article controller in the admin area and implement an article service with a get all method to list all articles, wiring dependency injection and a model.

Learn to create a template for listing all articles in an ASP.NET Core app, wire article and user data, display article images, and add edit and delete actions.

Fix small design problems by cleaning UI: remove unused button and table, adjust columns for name, surname, and title, and format the created date with a short date function.

Create a category controller in ASP.NET Core, wire it to a category service via dependency injection, and implement listing of all categories.

Learn to list all categories by scaffolding a category template, updating the model, and implementing an ASP.NET Core category controller with index, edit, and delete actions.

Learn to add a new category using the admin category controller and service, implementing get all, insert, and post flows, with form handling and result messaging.

Create a category add template by copying the existing file, renaming the model to category, and applying data annotations for category name, slug, and display name.

Learn to create a category add template and manage categories in admin, including adding, editing, and deleting, with a focus on aligning the table name with controllers and services.

Learn to implement a category update action by adding a get function and an update function to the category service, wired through the category controller and admin service.

Learn how to update categories in a web app by editing category fields, handling IDs, names, and slugs, and testing changes in the admin interface.

Implement a delete action result for categories in ASP.NET Core by adding a boolean delete method in the category service and wiring it to the category controller.

Implement category deletion in an admin panel by wiring the delete flow in the category controller, confirming with a yes/no prompt, and updating the category service with queries.

Navigate the admin panel to delete an article by clicking the delete button, confirm the action, and implement the article controller and article service delete function using get by id.

Learn to implement an article edit action result in ASP.NET Core by fetching article data, retrieving categories and cities from services, and passing a prepared model to the view.

Create an article edit template in an ASP.NET Core project, featuring a form with hidden article id, status radio buttons, slider post option, and a dynamic category select list.

Develop an article edit template in ASP.NET Core that binds title, image, city, category, content, and status, includes image display and date fields, plus submit handling.

Fix old design problems and implement the edit post method by wiring article controller and service, updating city and category fields, and adding an update function with basic validation.

Learn to implement an update function in the article service, updating title, category id, status, and publishing date, with controller logic and admin panel testing.

Learn to implement a logout action result in ASP.NET Core 5.0 and Vue.js by deleting all cookies from the login controller and redirecting to the home page.

List articles by status, from pending to rejected, using an ASP.NET Core controller and a status-based service, with a single reusable template and dynamic UI titles.

Enable the home page by wiring article and category services via dependency injection, implement a get home action, and render articles, sliders, and categories on the homepage.

Learn to fetch and display home page articles using a get home function, filtering by status and slider flags, and render title, image, date, content, and comments via for-each loop.

Fix small design problems by using a short string function to trim content, creating slider-specific articles with distinct images, and conditionally displaying slider items on the homepage.

Display slider articles by iterating through posts with a for-each loop, rendering post image, title, and content, and filter to slider items based on the slider attribute.

Learn to create article detail URLs by configuring the article controller's detail action and using title-based parameters in the article service, enabling slider-based arrivals on the home page.

Learn to solve two big problems in an ASP.NET Core and Vue app: manage database connections automatically and fix semicolon vs equals syntax for article creation and image upload.

Display article category names by joining articles with the categories table, extend the article model with a category property, and render the category slug in the post list.

Create a category controller in ASP.NET Core by wiring in category and article services via dependency injection, and implement an index action to list articles by category.

Learn to implement a category index action result in ASP.NET Core, using category and article services to return categories and articles for a specific category.

Create public category service methods with parameterized dynamic queries to fetch a category and list articles by category, filtering by status and category id.

Learn to display articles from a specific category by configuring templates, category controller and routing, and by adapting views to show category articles tied to the selected slug.

Learn to implement previous and next article navigation by extending the article model and service, and updating the controller to fetch adjacent records from the database.

Learn to display previous and next articles in your template by wiring image paths, titles, and navigation classes, then run and refresh the project to see seamless article transitions.

Learn to implement pagination for category articles in a .NET Core and Vue app by building a pagination model, helpers, and an article service to count and fetch items.

Explore a three-part pagination model for category articles, computing total count and page count from a decimal page size using math functions, and assemble the filtered article list by category.

Implement category pagination by introducing page, page size, and offset, modify the get category function, and integrate a pagination model and helpers to fetch and display paged articles.

Complete category article pagination by building a dynamic page navigator with a for loop, calculating page counts, and generating page links in the category index.

Learn to implement pagination for category articles in an ASP.NET Core app and Vue.js. Wire a pagination model into the template, manage active page states, and apply active styling.

Learn to implement an ajax-based comment submission on an article detail page, sending name, email, and message without a page refresh and handling json responses.

Create a comment service by adding a new service class, wiring database connection and configuration, and implementing insert logic for comments with proper primary key and defaults.

Learn to create a comments controller in asp.net core 5.0, wire article and comment services, and handle adding a comment with article id and text, returning a json success.

Post and display comments on the article detail page by expanding the model with a comments list and wiring a comment service and controller to fetch by article id.

Implement a reusable article search feature by building a single site component, a get-based form with q, and a home controller action that queries by title or content.

Learn to create a search template file for an ASP.NET Core 5.0 and Vue.js project, configure a home controller action, and display article lists with optional pagination.

Create a right side components file to display categories and most popular articles across templates, using dependency injection for category and article services and a take query ordered by hits.

Learn to create and use a right side component in templates, organizing shared components, render all categories with search, and display popular posts and articles in a live app.

Modify the right side template by updating the rightside component to display articles with categories, titles, publishing dates, and images, and wire links to detail and popular articles.

Reuse existing pagination helpers to create article pagination for the home page, configure article service to count and fetch articles, and wire the page parameter to finish the project.

Create two pagination service functions to count articles and to retrieve articles by page, using a page size, offset calculation, and joins with categories with status filters.

Create and integrate pagination for the homepage by adding pagination helpers and updating the pagination model and controller to handle the page parameter and render article lists.

Solve small problems and finish the project by debugging a running ASP.NET Core 5.0 and Vue JS app, fixing syntax errors, pagination, and data display for hits and comments.

Open Visual Studio, create a new .NET core 5.0 project named shop, and enable runtime compilation. Install packages, including entity framework and design, then configure MySQL data entity and rebuild.

Create a data access layer project in the solution using a .NET class library, add entity framework, and install MySQL data provider for database access.

Install the pomelo package as a MySQL database provider for Entity Framework Core, check dependencies for a compatible EF Core version, and install via Package Manager Console.

Create and configure a database for a professional project with 18 tables, generate classes for each table using Pomelo, and set up an Entity Framework context with package manager console.

Learn how to create a database from scratch using migrations in ASP.NET Core. Define tables and a context, then apply migrations to update the database.

Learn how to create domain entities for a database, such as address and order, and map their relationships as the schema evolves. Follow step-by-step entity creation.

Develop and wire up a suite of entities for an Asp.Net Core and Vue app, including products, brands, categories, addresses, cities, orders, order items, and payments.

learn to create an admin service in a new asp.net core project, set up a database context, and implement add, lead, update, get by id, get list, and save changes.

Learn to implement admin service functions, including add, delete, update, get by id, and get list with optional filters using a database context and expressions.

Learn to create a bank service by duplicating and renaming the admin service, define its relationship with bank installments, and adjust the get function and includes for proper data retrieval.

Create multiple services for the Asp.Net Core project, define their relationships (city, users, orders, addresses, products), and implement get by id while renaming services.

Develop and wire up multiple services for an Asp.Net Core project, including city, addresses, users, orders, order item, and page services, while establishing and correcting relationships and naming conventions.

Explore building services for an asp.net core and vue project, including payment, product, unit, and shipping services, with entity relationships to orders, users, brands, categories, and provinces across 18 tables.

Create and configure product, province, setting, shipping, unit, and user services, wiring relationships with baskets, orders, addresses, and cities.

Learn to create interfaces for services, implement them in concrete classes, and wire these interfaces through project references and inheritance as shown.

Define public interfaces for admin and bank services, add methods such as delete and update, and wire them with concrete service implementations.

Create and refactor public service interfaces for brand, category, and order item services, replacing references and ensuring public interfaces across the codebase, with plans to finish in upcoming lessons.

Build and rename multiple service interfaces, including order, order item, page, payment, product, and province, and implement inheritance to manage eighteen tables across the project.

Finish implementing interfaces for setting, shipping, unit, and user services by copying names, inheriting interfaces, and applying mappings, then build the admin panel and install a new picture package.

Learn to set up the business layer by creating a BL folder and BL interfaces, plus a services folder for admin and edmondo interfaces with six core functions.

Create and organize bank-related BL interfaces and services in a step-by-step workflow, including bank installments, bank service, basket, and category BLs, and plan multiple BL projects.

Create and configure the BL folder and BL interfaces for orders, items, services, payments, products, provinces, shipping, and unit entities, using copy-paste and find-and-replace to standardize naming.

Create a business layer project, implement interface members in admin class, and install packages for mapping and dependencies to enable get, get by id, get list, delete, login, and update.

Learn to build automapper profiles and map domain objects to database objects. Create maps for address, user, order, admin, bank, basket, product, category, city, and province with reverse mappings.

create and map complex entity relationships in a database context, linking orders, users, addresses, and payments with items, products, shipping, and provinces and cities.

Register services in startup to wire dependencies across projects, configure mapping with AutoMapper, and register singleton services via interfaces.

Learn to implement admin BL functions in ASP.NET core 5.0 by wiring dependency injection and mappers, and a context; create and delete admin entities, and outline login and update methods.

Explore building admin business logic functions in ASP.NET Core 5.0 and Vue.js, including get by id, list retrieval, login, and update flows with entity-to-do mapping.

Create business logic classes in ASP.NET Core 5.0 by implementing interfaces, wiring bank and bank service entities, and performing CRUD operations: update, get list, get by id, and delete.

Create and rename bl classes for category, city, order, and order item, apply lowercase conventions, and prepare seven bl classes.

Learn to create bl classes for payments, product, province, shipping, units, and users, and wire up their services in an admin panel, then rebuild the solution.

Learn to define and register many startup services, create interfaces for address and other domains, and wire bank, order, product, shipping, and payment services into the app.

Add and wire business layer services across the startup, duplicate and rename modules, remove unused services, and verify zero failures before planning the admin panel.

Create an admin area by configuring endpoints and adding a home controller. Build a new admin layout and adjust shared folders to support the admin panel.

Create and customize an admin layout by importing a free template, organizing assets, creating a layouts folder, and updating image and script paths in an ASP.NET Core and Vue.js project.

Modify the layout file to fix issues, implement the random body function and daytime function, and refine the admin panel and login action result.

learn to create an adminauth class by defining an admin model and applying action filters in asp.net core, with password encryption and cookie-based admin login.

Learn to create an encryption class for your ASP.NET Core project by integrating a proven encryption method, defining a static key, and hashing and decrypting passwords for secure authentication.

Create and customize a login form within the admin panel, build a login controller, and wire the login page with assets and layout adjustments for an ASP.NET Core project.

Learn to implement a login flow in ASP.NET Core 5 using a get IActionResult action and a post method. Use dependency injection, cookies, and password handling to secure admin login.

Implement a login post action in asp.net core 5.0, validating admin credentials, using antiforgery tokens, and issuing cookies for user id and username, then redirecting to the home index.

Learn to build an admin list page by creating an admin controller and index view, integrating data tables for pagination, and enabling export options like Excel, PDF, and print.

Inject the admin business logic into the controller, fetch the admin list, and render usernames, names, emails, and created dates with edit and delete actions.

Create an admin create page in an asp.net core and vue project. Build the create action and a horizontal icon form for username, name, surname, email, start date, and options.

Modify the admin create form by updating fields like username and email, removing unnecessary password fields, and applying old data annotations to the model in a post form.

Learn to implement data annotations for forms in asp.net core, including required, max length, min length, display name, and data type, with custom error messages and jquery validation integration.

Learn to create a new admin user in asp.net core by implementing the admin controller create action, validating input, checking username availability, encrypting password, and handling errors.

Debug and fix common admin creation issues in a full stack setup. Resolve missing get mapping, switch to login flow, and troubleshoot MySQL configuration and confirmation to create admin users.

Demonstrates solving admin form issues in asp.net core 5.0 and vue js by replacing checkboxes with radio inputs, and adjusting database fields and defaults for confirmation and active flags.

Learn to implement an admin edit workflow in asp.net core 5.0, including an edit action with an id, view wiring, and post submission while managing password display and encryption.

Develop your own HTML helper in ASP.NET Core by creating a dedicated helper project, configuring dependencies, and building reusable inputs for forms step by step.

Learn to create a custom input tag helper in ASP.NET Core by defining a class, importing Razor tag helpers, and declaring attributes like type and value to render three classes.

Create your own input tag helper to render input elements, handling hidden and non-hidden types by inspecting type, applying attributes, and generating the appropriate output in the view.

Build and customize an input tag helper in ASP.NET Core 5.0, setting default text type, dynamic classes, placeholders from display name, and validation attributes.

learn to build a custom input tag helper in asp.net core by adding required attributes and data metadata, and apply min length, max length, and data type validations.

Create and configure input tag helper attributes with required validation and custom error messages using data annotations, and structure labels and spans for a clear, accessible form.

Learn to use a custom tag helper in HTML to render input fields with labels, placeholders, and icons, configuring names and styles in admin edit forms.

Learn how to edit admin users through a form, adjust icons and fields, implement hidden inputs and post edit flow, encrypt passwords, handle errors, and update the admin list.

learn how to edit admin records in an asp.net core and vue js app, fix display of values, and implement password and email input types in the admin panel.

Implement admin deletion in an ASP.NET Core MVC app by adding delete actions and post methods, using try-catch blocks, and redirecting to the admin index after removal.

Learn to list banks in the admin panel by building a bank controller and index view; create banks with logos and configure fields like name, description, instalment, and order.

Learn to create a new bank object using an IActionResult, configure login state, use admin data, and set up the create action with bank model and input helpers.

Create a single file upload tag helper for ASP.NET Core, wiring a Razor component, setting attributes, and integrating with Dropzone and JavaScript to handle image uploads.

Discover how to add a dropzone drag-and-drop image uploader to an HTML page using Dropzone.js, configure single-file uploads, initialize with JavaScript, and integrate an upload helper for image processing.

Discover how to display the upload tag helper in a template by making it public and wiring it into the create bank form, addressing display and validation challenges.

Create and integrate an upload helper class, organize upload folders for banks and products, configure hosting environment, and wire the helper into the bank controller to handle image uploads.

Learn to create a new bank object using a post action, validate the model, handle errors, and support image uploads with secure forms and redirects.

Learn to upload images using a dedicated upload model, configure the folder, handle single image uploads, and resolve common console and path errors.

Learn to edit a bank object in ASP.NET Core, fix image display with hidden fields, validate and truncate descriptions, and implement a targeted edit action and view.

Learn to implement an edit post method to update bank objects, wire the bank controller with an update flow, and test image upload interactions in the bank list.

Learn how to delete bank objects by id with try-catch error handling, returning to the bank index after a successful delete.

Create the brands table with a primary key, unique name, slug, display order and description; then implement a brand controller index action to list brands in the admin panel.

Learn to create a brand template file by defining name, slug, title, description, and display order, then manage brands via the admin panel and corresponding database entity.

Create a friendly url function to sanitize brand inputs by removing or replacing special characters, trimming, and normalizing Cyrillic to latin using a C# extension with regex.

Learn how to create a new brand object in ASP.NET Core with Vue.js, including slug handling, description, title, and database updates in the brand controller.

Learn to update a brand object in an ASP.NET Core and Vue.js app by implementing edit, create, and get functions, handling errors, and updating brand data.

Learn how to delete a brand object using a delete action, leveraging post methods and try-catch error handling, and return to the index on success.

List provinces in an asp.net core 5.0 and vue js app by creating a province entity, defining name and order, and building an index view to display them.

Learn to create a new province object in an ASP.NET Core 5 app by implementing a create action, binding form data to a province domain object, and validating model state.

Create a custom button tag helper in asp.net core by defining attributes such as name, value, and type. Use a process method to render the button markup.

Learn to edit a province object by implementing get and post edit actions in the province controller, updating the province, and redirecting to the index with a tailored edit template.

Learn how to delete a province object by id, remove related results, and redirect to the provinces list, with error handling in an ASP.NET Core and Vue.js setup.

Create a unit table with name and short name, and implement unit controller with create, update, and delete operations using service providers, following the province controller pattern.

build template files for the unit object, including index, create, edit, and delete views, wired to controllers and layouts, with provinces and data annotations for required name and short name.

Create a city object by defining a city model and controller, establishing a province relationship, and using include to load province data for display in the city list.

Learn to create a city in ASP.NET Core 5.0 by selecting a province in a dropdown, binding city data to a view model, and implementing create action with error handling.

Learn to create a city object in an ASP.NET Core 5.0 app, using data annotations, a post method, slug handling, and model validation in the city controller.

Learn how to modify and edit a city object in ASP.NET Core 5.0 using a city model, update fields and province data, and save changes via a post method.

Learn to implement a delete operation for city objects in an ASP.NET Core 5.0 app, including a post method, try-catch handling, and updating the admin panel and front pages.

Learn to create a select box tag helper for asp.net core 5.0 and vue js, detailing attributes, item lists, and model binding for rendering the control.

Explore creating a robust select box tag helper in asp.net core 5.0 and vue, including required validation messages, data attributes, and for each loops to render items.

Learn to create a select box tag helper in ASP.NET Core, including default text and value, data attributes, label and control classes, and how to render the final select element.

Learn to list categories from the category table, using attributes like name, description, parent id, status, slug, and display order, while filtering out deleted items.

Create a new category by defining a category model with parent relationships, configuring a controller, and using a select box to list parent categories with status-driven display.

Learn to implement a post create action result for categories, including parent category handling, slug generation, and setting page titles, descriptions, and metadata in ASP.NET Core 5.0 and Vue.js.

Learn to build a checkbox tag helper in ASP.NET Core, defining attributes such as model expression and items, and implementing the process method to render and validate checkbox state.

Discover how to create a checkbox tag helper in ASP.NET Core (part two) by using a foreach loop to generate inputs, labels, and required attributes alongside data annotations for validation.

Learn to create an edit template file for categories in an ASP.NET Core MVC app, including form fields, status checkboxes, hidden IDs, and updating categories via the controller.

Learn to edit categories by updating category data, using data annotations, validating the model state, and reflecting changes in the category list with updated descriptions, page titles, and meta descriptions.

learn to perform a soft delete of categories in asp.net core 5 by using a delete action that sets deleted to 1 and redirects to index, showing only non-deleted items.

Learn how to create a new product_image table to support multiple images, with columns for image id, product id, address, and order, plus primary key and foreign key to products.

We will create the required classes for the product image table and switch to a database context, defining the product image entity and its relationship to product.

Create the necessary entities, interfaces, and a product image service to manage product image data, establish relationships, update mappers, and rebuild the solution to support uploading multiple images.

Create a product controller and integrate it with an admin controller, define the product model and lists for products, categories, brands, and images, and set up services for dependency injection.

Learn how to list products in an admin panel by building a product list view that shows image, name, price, category, brand, and status.

Learn to create a product using get and post actions in asp.net core 5.0. Build the admin panel, product controller, and models with category and brand lists.

Create a product creation template file with attributes like category and brand selects, image upload, and fields such as name, price, description, and status.

Explore data annotations for product fields in asp.net core 5.0 to validate names, prices, and discounts, and define category, brand, and unit relationships with templates and tech helpers.

Learn to fetch and display subcategories in a Vue.js app by selecting a category, using axios for requests and a Regius-based setup, plus a controller endpoint that returns subcategories.

Learn to display subcategories by fetching subcategory data from the response, build a custom select list for parent categories, and handle on-change events with data binding to the model.

learn to implement a discount feature in asp.net core 5.0 and vue js app, including category and subcategory selection, a discount input, and a discount date with a date picker.

Learn to upload product images in a asp.net core and vue js project, including debugging uploads and implementing single and multiple image uploads.

Learn to create a new product using post methods, assign brand and category IDs, validate the model state, and manage product data including name, description, page title, and metadata.

Learn to catch and display validation errors by checking model state, building an errors list, and handling foreign key constraints when creating products.

Keep form data on error by preserving entered values and reloading categories and brands for quick correction.

Create and manage product units by building a unit list, setting a default unit, and wiring unit selection in product creation within an ASP.NET Core and Vue.js app.

Learn to create and edit a product with an edit template, fix category and subcategory selections and image display, in an ASP.NET Core and Vue project.

Edit products in an asp.net core and vue.js app by implementing a post-based update, handling image uploads, displaying current images, and updating name, price, returnable, and discount.

Learn how to delete a product object through the admin controller by retrieving the product by ID, calling the delete action, and confirming deletion in the ui.

Learn to upload multiple images for a product with ASP.NET Core 5.0 and Vue JS. Create an image upload action and bind images to a product via its id.

Modify the Dropzone to enable multiple image uploads, configure the action, and implement frontend scripts with Dropzone, JavaScript, and axios to manage uploads and image removal.

Learn how to implement a multiple image upload workflow in ASP.NET Core, including a controller action, form handling, image address creation, and front-end display with a delete option.

Learn to create a template for multiple image uploads and a delete image action for product images, wiring up image handling in asp.net core.

Learn to implement and debug multiple image uploads on the admin product page using ASP.NET Core and Vue.js, including binding fixes and main image handling.

Learn to create a web layout by assembling headers, footers, and content, integrate images, scripts, and assets, and tailor pages like index and lost password.

Fix font imports to display icons and adjust the layout by removing unused sections; place the underbody after headers, replace images, and start designing the index for the next steps.

Learn to build and integrate a slider by inspecting the page, copying slider classes, creating a slider partial, and including it in the index to render slides.

Create a home view model containing category, product, and brand lists. Initialize them in the constructor and wire the model into the home controller using dependency injection.

Create the index template by composing the layout, integrating sliders, categories, products, and brands, wiring a home controller to supply a view model with lists, then run and troubleshoot.

Add new fields to the database, including the home page category and image, for categories. Update the context and migrations to display selected categories on the home page.

Create new home page categories by uploading subcategory images through the admin panel and category controller, organizing electronics like laptops, smartphones, headphones, and tvs with parent categories and display orders.

Display categories on the home page, render subcategories and products, manage category data and images, and implement for each loops to show electronics, women, and men categories.

Learn to display subcategories on the home page by correcting the foreach loop, filtering by parent category, and rendering subcategory images and names.

Learn to fix subcategory images, update category records, upload images, and show only four categories by leveraging display order and order by display_order in your shop database.

Display products across categories and subcategories, filtering by the showcase value. Use two nested for-each loops to render category groups and their products with images from the old image field.

Build dynamic product details for the home page by rendering category names, product names, and price with discount logic, and connect them to the database for listing.

Learn to create a category page by building a left-side filter template, wiring a category controller and index partials, and troubleshooting image display and layout issues for product listings.

Create a category product model with total, product list, and page count, and implement a pagination helper to fetch paginated category products from the database for display.

Create a pagination helper class to paginate category products using per page and total products, calculating the page count, and rendering page numbers with an active state and proper links.

Define a new category model with lists for categories, products, and brands, and implement a get-by-category per-page function to power pagination in the category controller.

Build a category index in ASP.NET Core 5.0 by wiring a category controller with dependency injection, handling slug and page, and retrieving category and products for parent and child categories.

Implement a category index in ASP.NET Core 5.0 with per-page pagination, calculate skip, fetch category products via a pagination helper, and return a model containing product and category lists.

Create a template file by binding a category products model, loop through products to render image, category, name, discount, and price, and integrate the pagination helper.

Display products with pagination in the template, fix category model issues, and implement a left sidebar with category filters to improve the product listing.

Learn to list categories and subcategories in a template, render a parent–child category tree, and replace jQuery with a clean layout for left-side navigation.

Learn to implement a min and max price filter to display and filter products using query parameters and a get method, with pagination considerations.

Learn to modify min and max price filters for products, integrate them with the pagination helper, and ensure correct display across categories.

Display brands in the template by grouping products by brand and listing only brands with products, using product data rather than querying all brands in the interface.

Learn to display brands in the template by pulling brand data from products and showing only brands with at least one product. Use checkboxes to filter by brand ids.

Learn to filter products by brand by introducing a brand id attribute in the controller, wiring brand filters into queries, and handling brand-based search and pagination.

This lecture shows how to assemble a product detail page by creating product and category models, a product list, and controllers, plus implementing brand filters and dependency injection.

Create a product detail template, set and verify stock values in the database, and build product models to display products when stock is greater than one.

Create a product detail template and wire up get by id and slug to display the product, while debugging database access and image paths.

Learn to display a product’s main image and multiple images using a for each loop, fix console issues, and bind image data to the product model’s image collection.

Create a product detail page with a main image, additional images, price with discount, stock, and description, using loops in an ASP.NET Core and Vue.js project.

Refine the product detail page by removing unused sections, display the description and stock left with dynamic messaging, and adjust images and price details including discount pricing.

Finish asp.net core 5.0 and vue js product detail page by displaying product images with zoom and adding a related products list from the same category, excluding the current item.

learn to create urls and category names in templates, implement category and product pages, handle parent and subcategory logic, and render category paths and product names.

Create a user controller and sign up workflow in asp.net core app, building a user model with city and province lists, wiring dependency injection, and updating the sign up template.

Create a signup html template to register users, wiring a sign-up form to a user model with validations, and post to signup.

Learn how to use Vue.js to display provinces and cities in a form, and fetch related cities with Ajax and Axios when a province changes.

Learn to use data annotations for user sign-up, validate fields like name and email, and manage provinces and their cities, including post actions and admin panel display considerations.

Register a user in asp.net core 5.0 by building a post method with anti-forgery, form collection, and a bound model to validate email. Encrypt passwords.

Learn to implement user registration in ASP.NET Core with Vue.js by validating unique emails, encrypting passwords, saving new users, and using cookies to remember signed-in users.

Finish the user registration page by resolving errors, importing the MySQL DB context, validating and saving user fields (name, surname, email, password), and preparing the index login flow after registration.

This lecture demonstrates constructing a login form in an ASP.NET Core project with Vue.js, including configuring email/username and password fields, a post method, and a basic login flow with redirects.

Build a login flow in an asp.net core 5.0 app by validating username and password from a form with antiforgery validation, decrypting the stored password, and issuing cookies to persist the session.

Learn to create a user profile page in an ASP.NET Core app by building login and sign-up flows, dashboard template, and a profile view with username, address, and recent orders.

Modify the user profile page by troubleshooting login state, using cookies to display the user's name, and aligning the dashboard with the current user's username and id.

Learn to add items to the cart in an ASP.NET Core 5.0 and Vue.js project by configuring the template form, hidden product fields, and basket controller actions.

master adding items to a basket by posting form data to an ASP.NET Core 5.0 controller, creating or updating the basket with user and product identifiers.

Learn to create a new basket and update existing ones using a get function and product-based logic in an ASP.NET Core and Vue JS project.

Demonstrate creating a basket index action result in the biscuit controller, define a biscuit model, assemble a biscuit list for the shopping cart, and show totals.

Modify the cart card template in an ASP.NET Core and Vue.js project by updating the basket model and rendering image, name, category, price, shipping, tax, and totals.

Learn to display shopping cart items by fetching baskets for a user, including related products and categories, computing the total price, and supporting update, delete, and clear actions.

Learn how to delete a basket from the shopping cart in an asp.net core and vue js project by implementing a delete action in the basket controller and refreshing cart.

Learn to clear the cart by deleting all baskets using a delete all action triggered by a clear cart button, via the mascot controller and basket service with user id.

Update cart items and delete all using the basket service, implementing update logic in the interfaces and controller, and handling item quantities via form input.

Implement a delete by id function in the basket service, duplicate it for the interface and controller, and use the database context to remove and save changes.

Debug and refine the cart update flow in the basket module, fix minimum data values, choose the update method, and align login state, cookies, and sign in/out in the layout.

Create a logout function by updating the user controller to delete all cookies and redirect to the login page, ensuring signed-out state across the app.

Create a pay controller and wire up checkout by injecting basket, address, shipping, payment, order, and order item services, then process payment and place the order.

Create an index action for the pay controller in ASP.NET Core 5.0, pulling basket, address, shipping, order, and payment data via cookies and the HTTP context.

Create a template for the pay controller index, integrating a model, selecting addresses and shipping methods, and configuring checkout content through drag-and-drop edits.

Create and display address and shipping objects in a template by using for-each loops and radio inputs, binding to the address and shipping models with IDs and prices.

Build a Vue js interface to select address and shipping method with checks that alert when either is missing.

Display address and shipping in the template by establishing address relationships (city, province), loading via address service with includes, and building a form with address and shipping ids for checkout.

Master how to implement a checkout action result in asp.net core 5.0 by handling form data, addresses, shipping, and basket logic through post requests.

Modify the checkout template to include email, card details, and expiry month and year, remove unused fields, and update the controller to test the checkout flow.

Create a checkout template in asp.net core with vue js, displaying basket items, address, subtotal, shipping, grand total, and a payment form with security code and payment method.

Finish the checkout flow by implementing a checkout template that displays cart items, shipping methods, address, and totals, with iterative debugging in an ASP.NET Core and Vue JS project.

Learn to implement a payment flow in ASP.NET Core by calculating the grand total with shipping, formatting totals to string, and preparing a post payment action.

Build a payment workflow in asp.net core by creating payment records, calculating total with shipping, and routing through credit card, PayPal, or cash on delivery payment types.

Learn to implement a payment flow in ASP.NET Core 5.0 and Vue.js, handling credit card data and security tokens, then create orders after payment with shipping and currency details.

Modify the database by removing unused fields, correcting relationships between orders, payments, and order items, and adding user_id, order_id, product_id, price, and total_price, with created and updated timestamp fields.

Learn to build and save order items and payments by iterating basket items, calculating discounted and normal prices, and returning a success result in a payment workflow.

Finish implementing the payment i action result by validating checkout details, updating the payment and order records, and testing the checkout flow end-to-end with order items and totals.

Learn to create an order action result by wiring a dedicated controller with basket, address, shipping, and payment services, and display the user's orders in a model-driven index view.

Create and tailor an orders template file in an ASP.NET Core 5.0 and Vue.js project, displaying orders, order items, and product details, while updating the left side menu.

Create an orders template by building an index system and iterating over payments and order items with foreach loops, while displaying product details, images, and the total price.

Create a static payment status function with a switch over integer statuses (0–4) to return order states, and integrate it into the orders processing and admin workflow.

Learn to create an orders template file in asp.net core 5.0 and vue js, filtering orders by last 5 days, 15 days, 30 days, and six months.

Create and troubleshoot an orders template in ASP.NET Core with Vue.js, wiring controllers and payment data, and implement get-based filtering for last five days, last thirty days, and all orders.

Create a profile controller in ASP.NET Core 5.0, fetch and display all user information using a service provider and a profile model.

Build a reusable left-side html template for the profile section in ASP.NET Core 5.0 and Vue.js, displaying the current user's name and surname across the app.

Display and edit user information on a profile page by wiring username, surname, email, phone, gender, and birthday through profile controller, model, and forms.

Learn to edit a user profile in ASP.NET Core by building a profile edit page that shows birthday as day, month, year and updates via form collection.

Learn to edit user profiles with a birthday form (month, day, year), gender, email, and phone fields, using a post-based update flow and basic validation.

Learn to edit a user profile in ASP.NET Core using a post method, updating name, surname, phone, and birthday, handling errors, and redirecting to the index.

Debug and fix the edit user profile feature by inspecting birthday and gender handling, adjusting updates logic, and validating display of birthday and gender in the profile form.

Create an address book page by displaying a user's multiple addresses, modeling the data, establishing user-address relationships, and rendering the list with a loop.

Learn how to create an add address action result, define an address model with province and city relationships, and populate provinces in the profile controller.

Modify the left side partial to load provinces and cities for the address form dropdowns, using on-change to fetch cities via a profile controller and return JSON.

Apply data annotations to the add address template and update the address entity with validation for username, surname, phone, address, city, province, country, and zip code.

Modify the add address template to create a user address, including province and city handling, model binding, and necessary conversions. Validate inputs and redirect to the address book on success.

Demonstrates editing addresses in a user profile by implementing an edit address action that uses the address id, retrieves the user, and binds the address model in the address book.

Learn how to edit and update user addresses in the ASP.NET Core 5.0 and Vue JS app, including implementing get and post methods, address model, provinces, and form validation.

Edit addresses securely in part 3 by using updated at and created at fields, enforcing user id checks to prevent editing other users' addresses.

Build an admin panel order action result by creating a controller that retrieves new orders with status zero. Display an index showing username, email, total price, quantity, and order items.

Build an order detail page by wiring orders and payments, updating the controller and views to display a specific order with included user data, using a detail template.

Learn to build an order detail template from scratch in an ASP.NET Core and Vue.js project, outlining a detailed layout with cards, tables, products, pricing, and payment methods.

Build an order detail template linking order items and product, integrate a payment service, and enable admin status and shipping date updates within a Vue and ASP.NET Core 5.0 workflow.

Complete the order detail template by wiring the post to update payments and orders, and display shipping date, chase numbers, and status when state is greater than zero.

Fix a small order workflow issue and implement the order detail action in the admin panel, wiring status, description, shipping date, chase number, and payment retrieval.

Create an order detail template by wiring template files and partials, linking payments and orders, and rendering an order’s items, payments, and total price with status logic.

Build the order detail template in part two by dynamically displaying status (processing, ship it, delivered), and listing products with image, name, quantity, and price, plus address and payment details.

Learn to create a reset password template file and implement a lost password flow that emails a reset link via a single email input form.

Create a reset_passwords table in the database, define id, email, and last_date columns, set a primary key and index, and update the database context to apply changes.

Create reset password functionality by configuring maps, interfaces, and a reset password service, and wiring it into the database context, startup, and controllers.

Explore implementing a password reset in an asp.net core 5.0 and vue.js project, including reset password service, post requests, and creating reset password objects with expiry.

Learn to reset a user password via email in an asp.net core 5.0 & vue js course, configure smtp settings, and send the reset message from your site.

Learn how to reset a user password by configuring an smtp client with yandex mail, defining email settings, and sending password reset emails from your app.

Diagnose and fix a series of small reset password issues by correcting database context names, service references, and capitalization to ensure the lost password flow works end-to-end.

Troubleshoot and configure the reset password flow in the ASP.NET Core and Vue app, focusing on correct configuration, email parameters, and debugging to enable the lost password page.

Learn how to implement a new password action result in asp.net core, including configuring reset password flows, email delivery with Yandex settings, and validating expiry to secure user resets.

Learn how to change a user's password using a post form with a forgery token, validate and encrypt the new password, update the user record, and redirect to the index.

Create a wishlist table in a web project by defining id, user_id, product_id, created_at, and updated_at, then set up primary and foreign keys to users and products with indexes.

Create the required classes for the wishlist table, define the wishlist entity, and map its relationships to user and product.

Learn to implement an add to wishlist action in an ASP.NET Core 5.0 app by building a wishlist model, managing user identity, and updating the wishlist with an action result.

Implement a delete from wishlist action result in an asp.net core 5.0 and vue js app, validating login via cookies, locating the wishlist item, and returning ok after removal.

Create json functions for our wishlist part 1 across pages, using two actions in the home controller to retrieve user basket and wishlist from cookies and display red heart states.

Develop a json-based wishlist function for Asp.Net Core and Vue JS. Manage add and remove actions via product and home controllers, return 1 or 0, and update wishlist view.

Modify the application layout to expose the wishlist and basket, create data structures for wishlist and basket, and bind them in the index and layout for dynamic updates.

Modify the layout to support the wish list and basket, render basket items with a for loop showing image, name, price, and quantity, and calculate the total for checkout.

Modify the layout to use the wish list and basket by fixing display issues, removing erroneous columns, and preventing endless json object loops with the json ignore function.

Discover how to modify layout to support our wish list and basket by using json ignore to manage relationships, prevent loops, and tailor product, category, and user data display.

Create a slider table in the database with id, title1, title2, description, and image, then implement the corresponding entity, service, and mapping to support sliders in the app.

Develop and wire a slider controller in ASP.NET Core 5.0. Populate the admin panel with a slider list and render all sliders in an index view via a service provider.

Create and manage sliders in an asp.net core 5.0 app: build a slider controller and index, handle image uploads, validate models, and redirect to index in the admin panel.

Learn how to create a slider and upload images in an asp.net core 5.0 and vue js app, including the slider entity and single image uploads.

Learn to edit sliders in ASP.NET Core MVC by using slider controls, try-catch blocks, and edit/index actions, including creating election results and redirects to maintain data integrity.

Learn to delete a slider in an asp.net core 5.0 and Vue.js app: locate by id, confirm deletion, and handle post requests with error handling.

Create a product search feature and build a search template file in an ASP.NET Core 5.0 and Vue.js project, including slider integration and search results with pagination.

Implement a product search action in ASP.NET Core 5, handling query, text search, sorting, and pagination to build a results list.

Implement a product search action with pagination in ASP.NET Core 5.0, using query parameters for search text, page, and per-page settings, and connect a pagination helper to display results.

Develop search results by wiring category and product list into the template, render product details and add to cart, and refine pagination with the helper.

Fix and optimize the search feature by correcting product queries, updating the guest list function, and implementing filters, sorting, and pagination in the search workflow.

Create a page controller to manage static pages stored in a database, with an index listing, and define a page model with title and slug for admin layout and creation.

Learn to create a new page in an asp.net core app by implementing a create action, handling slug and title, validating model state, and returning or redirecting to the page.

Learn to create a new static page in the admin panel using a text editor, set the title and slug, and integrate form editors and styles for content.

Learn to edit static pages in an ASP.NET Core MVC app by implementing edit and post actions, validating title and slug, and updating pages with redirects.

Delete static pages using a page controller by retrieving by id, performing the delete via post method, and redirecting to the index on success.

Create a live page controller and template to render static pages by slug, and wire the service provider to get required service for page data.

Learn to display static pages in a layout by creating components, wiring a service provider, and rendering a page list in a default layout.

Display categories in the template by updating the database to set include in top menu to one. Build a top menu component and render the filtered categories in the navigation.

Learn to render all categories and subcategories in a template using foreach loops and parent and child relationships with a top menu component in asp.net core 5.0 and vue js.

Fix small problems by modifying the cart display, updating the home and account sections, and cleaning up section contents and blog sections to ensure the page loads correctly.