Как сделать систему инвентаря?

[Tr0jan_Horse]

```
Creating an Inventory System: From Theory to Practice

Introduction
Inventory management is a critical aspect across various sectors, including logistics, retail, and IT. A well-structured inventory system ensures efficient tracking and management of stock, which can significantly impact operational efficiency and profitability. This article aims to guide you through the process of creating a simple inventory system, covering both theoretical foundations and practical implementation.

1. Theoretical Part

1.1. Definition of an Inventory System
An inventory system is a method used to track inventory levels, orders, sales, and deliveries. The primary functions and components include:
- Tracking inventory levels
- Managing stock across various locations
- Generating reports for analysis

1.2. System Architecture
The architecture of an inventory system typically follows a client-server model, where the client interacts with the server to access data stored in a database. Key technology choices include:
- Programming Languages: Python, JavaScript, etc.
- Frameworks: Flask, Django, Express.js
- Databases: SQL (e.g., PostgreSQL, MySQL) vs NoSQL (e.g., MongoDB)

1.3. Database Design
Data modeling involves creating tables, defining relationships, and establishing keys. A sample database structure for an inventory system might include:
- Products Table: product_id, name, category_id, supplier_id, quantity, price
- Categories Table: category_id, category_name
- Suppliers Table: supplier_id, supplier_name, contact_info
- Transactions Table: transaction_id, product_id, quantity, transaction_type, date

2. Practical Part

2.1. Setting Up the Environment
To get started, you need to install the following tools:
- IDE: Visual Studio Code, PyCharm, etc.
- Server: Local server (e.g., XAMPP, WAMP) or cloud-based (e.g., AWS, Heroku)
- Database: PostgreSQL, MySQL, or MongoDB

Create a project structure as follows:
```
/inventory-system
/backend
/frontend
/database
```

2.2. Implementing the Database
Here’s an example SQL script to create the database and tables:
```
CREATE DATABASE inventory_db;

USE inventory_db;

CREATE TABLE categories (
category_id INT AUTO_INCREMENT PRIMARY KEY,
category_name VARCHAR(255) NOT NULL
);

CREATE TABLE suppliers (
supplier_id INT AUTO_INCREMENT PRIMARY KEY,
supplier_name VARCHAR(255) NOT NULL,
contact_info VARCHAR(255)
);

CREATE TABLE products (
product_id INT AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(255) NOT NULL,
category_id INT,
supplier_id INT,
quantity INT DEFAULT 0,
price DECIMAL(10, 2),
FOREIGN KEY (category_id) REFERENCES categories(category_id),
FOREIGN KEY (supplier_id) REFERENCES suppliers(supplier_id)
);

CREATE TABLE transactions (
transaction_id INT AUTO_INCREMENT PRIMARY KEY,
product_id INT,
quantity INT,
transaction_type ENUM('add', 'remove'),
date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
FOREIGN KEY (product_id) REFERENCES products(product_id)
);
```
Populate the database with test data using INSERT statements.

2.3. Developing the API for System Interaction
Create a RESTful API to manage inventory. Below is an example using Flask:
```
from flask import Flask, request, jsonify
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://userassword@localhost/inventory_db'
db = SQLAlchemy(app)

class Product(db.Model):
product_id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False)
quantity = db.Column(db.Integer, default=0)

@app.route('/products', methods=['POST'])
def add_product():
data = request.json
new_product = Product(name=data['name'], quantity=data['quantity'])
db.session.add(new_product)
db.session.commit()
return jsonify({'message': 'Product added'}), 201

@app.route('/products/<int:id>', methods=['DELETE'])
def delete_product(id):
product = Product.query.get(id)
db.session.delete(product)
db.session.commit()
return jsonify({'message': 'Product deleted'}), 200

if __name__ == '__main__':
app.run(debug=True)
```

2.4. Creating the User Interface
For the frontend, you can use HTML, CSS, and JavaScript. Here’s a simple example:
```
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Inventory System</title>
<link rel="stylesheet" href="styles.css">
</head>
<body>
<h1>Inventory Management</h1>
<div id="product-list"></div>
<script src="script.js"></script>
</body>
</html>
```

2.5. Testing the System
Testing is crucial for ensuring system reliability. Use unit tests and integration tests. Here’s an example of a simple test for the API using pytest:
```
def test_add_product(client):
response = client.post('/products', json={'name': 'Test Product', 'quantity': 10})
assert response.status_code == 201
assert response.json['message'] == 'Product added'
```

3. Extending Functionality

3.1. Adding Authentication and Authorization
Implement security measures using JWT or OAuth. Here’s a basic example of JWT implementation:
```
from flask_jwt_extended import JWTManager, create_access_token

app.config['JWT_SECRET_KEY'] = 'your_secret_key'
jwt = JWTManager(app)

@app.route('/login', methods=['POST'])
def login():
username = request.json['username']
password = request.json['password']
# Validate credentials
access_token = create_access_token(identity=username)
return jsonify(access_token=access_token), 200
```

3.