Flask BDA
1.0.0
Hinweis: Noch in der Entwicklung!
Aktuelle Version: 0.0.0 Beta
Flask-BDA befindet sich noch in der Anfangsentwicklung und wird mit der Python-Version 3.8.6 getestet.
Aktuelle Roadmap und übergeordneter Projektplan: https://trello.com/b/uu4HNPBh/flask-bda-features-roadmap
Flask-BDA folgt bei seinen Veröffentlichungen der semantischen Versionierung mit einem {major}.{minor}.{patch} -Schema für Versionsnummern, wobei:
Veraltete Versionen bleiben für mindestens drei Nebenversionen nach Version 0.0.1 bestehen
Andere Lösungen wie Tableau, Power BI und Amazon QuickSight sind zwar fantastische Tools, konzentrieren sich jedoch auf die Berichterstellung, ermöglichen es Ihnen jedoch nicht, bei Bedarf Daten zu den Plattformen zu bearbeiten oder hinzuzufügen, was bedeutet, dass Sie zusätzliche Lösungen oder Software benötigen, um Ihre Geschäftsziele zu erreichen
Lösungen wie Excel sind für jedermann zugänglich und bieten Ihnen die Flexibilität, die Sie benötigen. Dennoch sind Ihre Daten verstreut und ermöglichen nicht ohne weiteres eine gemeinsame Informationsquelle für Ihr Team und Ihre Kunden. Darüber hinaus kann es sehr leicht passieren, dass Excel-Dokumente nicht synchron sind oder sogar gemeinsam genutzt werden, was Ihr Unternehmen einem Sicherheitsrisiko aussetzt.
Flask-BDA hilft Ihnen, indem es Ihnen die Kontrolle gibt, um schnelle, sichere Full-Stack-Anwendungen 2-5x (2-5-mal) schneller bereitzustellen. Ohne Bindung an einen Anbieter oder eine bestimmte Umgebung.
Flask ist ein von Armin Ronacher geschriebenes Open-Source-„Mikro-Framework“, mit dem Sie Webanwendungen in Python erstellen können. Die Bereitstellung nur eines kleinen Kernsatzes an Funktionen bietet eine erweiterbare Basis, die es Entwicklern ermöglicht, auszuwählen, welche zusätzlichen Tools sie für ihre Anwendung benötigen.
Obwohl Flask als Mikro-Framework bezeichnet wird, eignet es sich gut zum Erstellen kleiner und großer Webanwendungen. Flask wurde in Produktionssystemen von großen Unternehmen wie Twilio, Pinterest, Lyft, LinkedIn und Uber verwendet.
Flask-BDA hilft Ihnen, sich schneller zu entwickeln, indem es Ihnen eine bereits vorhandene Struktur für die Flaschenanwendung zur Verfügung stellt, die Ihnen Folgendes ermöglicht:
Behandeln Sie automatisch die mühsamen Aspekte, die die Softwareentwicklung verlangsamen
- Erstellen und verwalten Sie alle Datenbankverbindungen und komplexen Abfragen.
- Anwendungssicherheit mit benutzer- und rollenbasierter Zugriffskontrolle
- Automatische Audits für jede Aktion
Flask-BDA ist eine Low-Code-Plattform (das heißt, wir helfen Ihnen, indem wir einen Großteil des Codes für Sie schreiben), die Unternehmen die Tools zur Verfügung stellt, mit denen sie schnell sichere Anwendungen entwickeln und bereitstellen können, die auf jedem Gerät ausgeführt werden können.
Wir ändern die Art und Weise, wie Software erstellt wird, damit Sie schnell kritische Anwendungen jeder Größe erstellen und bereitstellen können, die sich mit Ihrem Unternehmen weiterentwickeln, und sparen Ihnen Zeit und Geld.
Entwickler können eine breite Palette von Anwendungen erstellen und bereitstellen – von Verbraucheranwendungen bis hin zu kritischen internen Geschäftssystemen –, die Entwicklern dabei helfen sollen, sichere Anwendungen schnell und effizient bereitzustellen, sodass Apps innerhalb von Wochen oder sogar Tagen bereitgestellt werden.
Flask-BDA bietet Full-Stack-Entwicklung von; Benutzeroberfläche, Geschäftsprozesse, benutzerdefinierte Logik und Datenmodelle, um sofort plattformübergreifende Apps zu erstellen. Wir stellen Ihnen ein Gerüst zur Verfügung, auf dem Sie bei Bedarf Ihren eigenen benutzerdefinierten Code hinzufügen können. Ohne jemals einen Lock-in.
Mit vorkonfigurierten Entwicklungsumgebungen reduzieren wir den Aufwand (und die Kosten) bei der Markteinführung und geben Ihnen die Flexibilität, zu entscheiden, wo und wie Sie die Lösung bereitstellen möchten.
Flask-BDA ist kostenlos und entwicklerfreundlich und ein kostenloses, quellenverfügbares Anwendungsentwicklungstool mit einer entwicklerfreundlichen Lizenz.
Flask-BDA kann für kommerzielle und private Projekte völlig KOSTENLOS verwendet werden.
Allerdings ist Softwareentwicklung immer eine kostspielige Angelegenheit:
- Sie müssen einen oder mehrere Softwareentwickler, Geschäftsanalysten, Designer, Projektmanager und andere Teammitglieder für die Entwicklung Ihres Produkts bezahlen.
- Ihr Produkt ist nie fertig. Ein Softwareprojekt muss immer weiterentwickelt werden.
- Wenn Sie ein Produkt liefern, arbeitet Ihre Konkurrenz bereits an neuen und verbesserten Funktionen, und Sie müssen in der Lage sein, die Nase vorn zu haben oder zumindest mitzuhalten, sonst werden die Benutzer zu Ihrer Konkurrenz wechseln.
- Sobald Sie Ihr Produkt nutzen, denken Sie und Ihr Team über neue Funktionen nach, die es noch besser machen und Ihre Prozesse verbessern.
- Fortsetzung der Wartung. Wenn Benutzer das Produkt verwenden, werden sie Möglichkeiten finden, es zu beschädigen, an die Sie noch nicht gedacht haben, und diese müssen behoben werden.
| Projektgröße | Anschaffungskosten | Laufende Kosten |
|---|---|---|
| Kleinere Projekte (2 – 6 Wochen Entwicklungszeit) | 11.250 $ | 563 $ – 1.125 $ (±10 %) pro Monat |
| Mittelgroße Projekte (2 – 4 Monate Entwicklungszeit) | 33.750 $ | 1.563 bis 3.375 US-Dollar (±10 %) pro Monat |
| Großprojekte (6–18 Monate oder länger Entwicklungszeit) | 156.250 $ | 3.375 $ – 15.625 $ (±10 %)/pro Monat |
| Projektgröße | Anschaffungskosten | Laufende Kosten |
|---|---|---|
| Kleinere Projekte (1 - 3 Wochen Entwicklungszeit) | 3.750 $ | 188 $ - 375 $ (±10 %) pro Monat |
| Mittelgroße Projekte (1 – 3 Monate Entwicklungszeit) | 11.250 $ | 375 $ – 1.125 $ (±10 %) pro Monat |
| Große Projekte (2–6 Monate oder länger Entwicklungszeit) | 52.084 $ | 1.125 bis 5.208 US-Dollar (±10 %) pro Monat |
Mit Flask-BDA verlieren Sie NICHTS von der Flexibilität der „normalen Entwicklung“, da standardisierte Entwicklungsmuster und bewährte Technologien verwendet werden.
Flask-BDA nutzt viele Open-Source-Technologien und nutzt vorhandene Technologie-Stacks, sodass Sie leicht andere Entwickler finden können, die dieselben Technologien verwenden. Dadurch müssen Sie keine teuren Lizenzgebühren oder Umweltkosten zahlen, unabhängig davon, wie viel Umsatz Ihr Unternehmen erzielt oder wo Sie sich in Ihrem Unternehmen befinden.
Beginnen Sie mit einer schnellen und einfachen vorkonfigurierten Entwicklungsumgebung in wenigen Minuten.
Keine komplexe Einrichtung erforderlich. Es ist nur Python (empfohlen 3.8.6) erforderlich.
Aktualisieren Sie Ihre Konfigurationen: Datenbankverbindungen und Anwendungseinstellungen.
Erstellen Sie Ihre eigenen Module und Datenstrukturen (Datenmodell), um verschiedene Datenbanken nutzen zu können.
Automatisch generiert, voll funktionsfähig:
AdminundMobileSeitenREST APIsmit einem Swagger-FrontendGraphQL APImit einem GraphiQL-Frontend, das einfach pro Modul verwaltet werden kann.
Konfigurieren Sie Seiten entsprechend Ihren spezifischen Anforderungen und teilen Sie sie ganz einfach mit Ihrem Team und Ihren Kunden.
Schreiben Sie Ihren eigenen benutzerdefinierten Code in ein isoliertes Modul, damit Sie andere Module nicht beeinträchtigen.
Integrieren Sie Module einfach in verschiedene Projekte.
Verwenden Sie für die Bereitstellung dieselbe Codebasis:
- Desktop
- Web
- Mobile
Zu den Umgebungen gehören:
- Docker
- AWS Serverlos
- Digitaler Ozean
- Heroku
- Geteiltes Hosting.
pip installiert ist (Pip sollte bereits installiert sein, da es mit den neuesten Python-Versionen geliefert wird). Falls dies nicht der Fall ist, installieren Sie es bitte hier: https://pip.pypa.io/en/stable/installing/python -m pip --version
HINWEIS: In dieser Dokumentation wird davon ausgegangen, dass Sie
pip3alspipausführen, daher werden alle Anweisungen mitpipgeschrieben. Wenn Sie möchten, dasspip3ausgeführt wird, wenn Siepipvon Ihrem Terminal aus aufrufen, können Sie vonpipaus einen Symlink zupip3erstellen:
pip install --upgrade pip auszuführensudo aus, z. B.: sudo pip install --upgrade pip nano ~ /.bash_profile
Fügen Sie in die Datei Folgendes ein:
alias pip= ' pip3 '
alias python= ' python3 '
HINWEIS: Möglicherweise müssen Sie Python 2.7 unter MacOS entfernen, da es auf meinen Distributionen vorinstalliert ist. Dies war sehr hilfreich, um dies zu erreichen:
sudo rm -rf /Library/Frameworks/Python.framework/Versions/2.7sudo rm -rf " /Applications/Python 2.7 "ls -l /usr/local/bin | grep ' ../Library/Frameworks/Python.framework/Versions/2.7 'und führen Sie dann den folgenden Befehl aus, um alle Links zu entfernen:
cd /usr/local/bin/
ls -l /usr/local/bin | grep ' ../Library/Frameworks/Python.framework/Versions/2.7 ' | awk ' {print $9} ' | tr -d @ | xargs rmNachdem Sie Python und
pipinstalliert haben, müssen Sie eine Abhängigkeit installieren, damit die Flask-BDA-Befehlszeilenfunktionen ordnungsgemäß ausgeführt werden:
pip install click
Zu den weiteren Abhängigkeiten, die Sie möglicherweise global installieren möchten (die jedoch beim Erstellen eines Projekts automatisch ausgeführt werden sollten), gehören:
pip install virtualenv
pip install flaskwebgui
pip install pyinstaller
Um mit der Erstellung Ihres ersten Projekts mit Flask-BDA zu beginnen, befolgen Sie die folgenden einfachen Schritte, um Ihre eigene vorkonfigurierte Entwicklungsumgebung in wenigen Minuten betriebsbereit zu erstellen.
In dieser Schnellstartanleitung erstellen wir ein Projekt mit dem Namen
"My Awesome Project". Sie können das Projekt jedoch beliebig nennen.
create_project.py heruntergeladen und ausgeführt, um Ihnen beim Starten eines Projekts zu helfen"My Awesome Project" curl -L https://raw.githubusercontent.com/RyanJulyan/Flask-BDA/main/create_project_git.py --ssl-no-revok -o create_project_git.py
python create_project_git.py --project= " My Awesome Project "
create_project.py heruntergeladen und ausgeführt, um Ihnen beim Starten eines Projekts zu helfen"My Awesome Project" curl -L https://raw.githubusercontent.com/RyanJulyan/Flask-BDA/main/create_project_git.py --ssl-no-revok -o create_project_git.py
python create_project_git.py --project= " My Awesome Project "
Hinweis: Wenn Sie keinen gültigen Projektnamen eingegeben haben, werden Sie dazu aufgefordert:
- Geben Sie Ihren Projektnamen ein, wenn Sie dazu aufgefordert werden, z. B.:
- Bitte stellen Sie sicher, dass Sie Ihren Projektnamen in Anführungszeichen setzen, um Fehler zu vermeiden, z. B.:
"My Awesome Project"
Invalid Project Name !
Please enter a valid project name :
"My Awesome Project"Hinweis: Sie werden feststellen, dass dadurch ein Ordner im selben Pfad wie die Datei erstellt wird: „create_project_git.py“. Dieser Ordner wird in Kleinbuchstaben geschrieben und alle Sonderzeichen entfernt und Leerzeichen durch Unterstriche ersetzt, z. B.:
my_awesome_project
Hinweis: Während der Entwicklung möchten Sie möglicherweise einen anderen Zweig oder ein anderes Repo vollständig verwenden. Dies kann beim Testen hilfreich sein oder wenn Sie sich vom Flask-BDA-Kernprojekt gelöst haben.
- Sie können beim Erstellen eines neuen Projekts
Owner,RepoundBranchangeben.
curl - L https : // raw . githubusercontent . com / RyanJulyan / Flask - BDA / RyanJulyan - Dev / create_project_git . py - - ssl - no - revok - o create_project_git . py
python create_project_git . py - - project = "My Awesome Project" - - owner = "RyanJulyan" - - repo = "Flask-BDA" - - branch = "RyanJulyan-Dev" - - create_venv = TrueHinweis: Für alle Anschlussarten noch zu testen!
Datenbankverbindungen sind in Flask-BDA schnell und einfach. Sie können eine oder mehrere Datenbanken haben und verschiedene Mandanten können ihre eigenen Datenbankverbindungen sowie ihren eigenen Datenbanktyp (SQLite, MySQL, SQL Server, PostgreSQL) haben.
Standardmäßig ist in Flask-BDA eine SQLite-Datenbank eingerichtet. Das liegt daran, dass Sie keine zusätzliche Infrastruktur benötigen, um es einzurichten und loszulegen, was SQLite zu einer schnellen und einfachen Wahl macht.
So ändern Sie die Standarddatenbank:
flaskbda ), einen neuen Benutzer ( flaskbda_user ) und ein neues Passwort ( password ).config.pyDATABASE_ENGINE für SQLite aus und kommentieren Sie die mysql DATABASE_ENGINE aus.DATABASE_NAME für SQLite aus und kommentieren Sie ihn in MySQL:DATABASE_HOSTDATABASE_PORTDATABASE_USERNAMEDATABASE_PASSWORDDATABASE_NAMESQLALCHEMY_DATABASE_URI für SQLite aus und kommentieren Sie den MySQL SQLALCHEMY_DATABASE_URI aus. ##########
# SQLite #
##########
# DATABASE_ENGINE = 'sqlite:///'
# DATABASE_NAME = os.path.join(BASE_DIR, 'databases/sqlite/default.db')
# SQLALCHEMY_DATABASE_URI = DATABASE_ENGINE + DATABASE_NAME
#########
# MySQL #
#########
DATABASE_ENGINE = 'mysql://'
DATABASE_HOST = ''
DATABASE_PORT = '1433'
DATABASE_USERNAME = ''
DATABASE_PASSWORD = ''
DATABASE_NAME = ''
SQLALCHEMY_DATABASE_URI = DATABASE_ENGINE + DATABASE_USERNAME + ':' + DATABASE_PASSWORD + '@' + DATABASE_HOST + ':' + DATABASE_PORT + '/' + DATABASE_NAME
DATABASE_HOSTDATABASE_PORTDATABASE_USERNAMEDATABASE_PASSWORDDATABASE_NAME DATABASE_HOST = 'localhost'
DATABASE_PORT = '3306'
DATABASE_USERNAME = 'flaskbda_user'
DATABASE_PASSWORD = 'password'
DATABASE_NAME = 'flaskbda' So ändern Sie die Standarddatenbank:
flaskbda ), einen neuen Benutzer ( flaskbda_user ) und ein neues Passwort ( password ).config.pyimport pyodbc .DATABASE_DRIVER .DATABASE_ENGINE für SQLite aus und kommentieren Sie beispielsweise DATABASE_ENGINE für SQLServer.DATABASE_NAME für SQLite aus und kommentieren Sie ihn im SQLServer:DATABASE_HOSTDATABASE_PORTDATABASE_USERNAMEDATABASE_PASSWORDDATABASE_NAMESQLALCHEMY_DATABASE_URI für SQLite aus und kommentieren Sie den try und except den SQLServer SQLALCHEMY_DATABASE_URI aus.Hinweis: Wenn Sie
SQLEXPRESSausführen und versuchen, eine Verbindung herzustellen. Bitte kommentieren Sie die SQLServer-SQLEXPRESSVariable aus. Dies wird imtrybehandelt,exceptum den richtigenSQLALCHEMY_DATABASE_URIzu erstellen
Hinweis: Wenn Sie eine Windows-Authentifizierung wünschen. Bitte kommentieren Sie die SQLServer-Variable
TRUSTED_CONNECTIONaus. Dies wird imtrybehandelt,exceptum den richtigenSQLALCHEMY_DATABASE_URIzu erstellen
##########
# SQLite #
##########
# DATABASE_ENGINE = 'sqlite:///'
# DATABASE_NAME = os.path.join(BASE_DIR, 'databases/sqlite/default.db')
# SQLALCHEMY_DATABASE_URI = DATABASE_ENGINE + DATABASE_NAME
#############
# SQLServer #
#############
import pyodbc # noqa: E402
DATABASE_ENGINE = 'mssql+pyodbc://'
# SQLEXPRESS = '\SQLEXPRESS' # for SQLEXPRESS
# TRUSTED_CONNECTION = 'yes' # for windows authentication.
DATABASE_DRIVER = 'SQL+Server+Native+Client+11.0' # for windows authentication.
DATABASE_HOST = ''
DATABASE_PORT = '1433'
DATABASE_USERNAME = ''
DATABASE_PASSWORD = ''
DATABASE_NAME = ''
try :
if SQLEXPRESS == ' \ SQLEXPRESS' :
try :
if TRUSTED_CONNECTION == 'yes' :
SQLALCHEMY_DATABASE_URI = DATABASE_ENGINE + DATABASE_HOST + ':' + DATABASE_PORT + SQLEXPRESS + '/' + DATABASE_NAME + '?trusted_connection=' + TRUSTED_CONNECTION + '&driver=' + DATABASE_DRIVER
else :
SQLALCHEMY_DATABASE_URI = DATABASE_ENGINE + DATABASE_USERNAME + ':' + DATABASE_PASSWORD + '@' + DATABASE_HOST + ':' + DATABASE_PORT + SQLEXPRESS + '/' + DATABASE_NAME + '&driver=' + DATABASE_DRIVER
except NameError :
SQLALCHEMY_DATABASE_URI = DATABASE_ENGINE + DATABASE_USERNAME + ':' + DATABASE_PASSWORD + '@' + DATABASE_HOST + ':' + DATABASE_PORT + SQLEXPRESS + '/' + DATABASE_NAME + '&driver=' + DATABASE_DRIVER
except NameError :
try :
if TRUSTED_CONNECTION == 'yes' :
SQLALCHEMY_DATABASE_URI = DATABASE_ENGINE + DATABASE_HOST + ':' + DATABASE_PORT + '/' + DATABASE_NAME + '?trusted_connection=' + TRUSTED_CONNECTION + '&driver=' + DATABASE_DRIVER
else :
SQLALCHEMY_DATABASE_URI = DATABASE_ENGINE + DATABASE_USERNAME + ':' + DATABASE_PASSWORD + '@' + DATABASE_HOST + ':' + DATABASE_PORT + SQLEXPRESS + '/' + DATABASE_NAME + '&driver=' + DATABASE_DRIVER
except NameError :
SQLALCHEMY_DATABASE_URI = DATABASE_ENGINE + DATABASE_USERNAME + ':' + DATABASE_PASSWORD + '@' + DATABASE_HOST + ':' + DATABASE_PORT + '/' + DATABASE_NAME + '&driver=' + DATABASE_DRIVER
DATABASE_HOSTDATABASE_PORTDATABASE_USERNAMEDATABASE_PASSWORDDATABASE_NAME DATABASE_HOST = 'MSSQLSERVER'
DATABASE_PORT = '1433'
DATABASE_USERNAME = 'flaskbda_user'
DATABASE_PASSWORD = 'password'
DATABASE_NAME = 'flaskbda'Stellen Sie sicher, dass für Ihre MS-SQL-Instanz Remote-Verbindungsrechte eingerichtet und aktiviert sind (siehe hier)[https://knowledgebase.apexsql.com/configure-remote-access-connect-remote-sql-server-instance-apexsql-tools/ ]:
Stellen Sie sicher, dass die Einstellungen für die „SQL Server-Konfigurationsverwaltung“ korrekt konfiguriert sind
HINWEIS: Ihre Installation erfordert
Client Tools Connectivity. Wenn Sie „SQL Server-Konfigurationsverwaltung“ nicht finden können, müssen Sie möglicherweise Ihre Installation ändern, umClient Tools Connectivityeinzuschließen
- Wenn Sie das „“ nicht finden können, müssen Sie möglicherweise stattdessen das Tool „Computerverwaltung verwenden“ verwenden. um darauf zuzugreifen.
- Dies scheint ein Windows 10-Problem zu sein
Multitenancy ist eine Softwarearchitektur, bei der eine einzelne Softwareinstanz auf einem Server ausgeführt wird und mehrere Mandanten (Clients) bedient. Multitenant-Software ermöglicht den Betrieb mehrerer unabhängiger Instanzen einer oder mehrerer Anwendungen in einer gemeinsamen Umgebung.
Flask-BDA unterstützt vertikal partitionierte Mandantenfähigkeit. Vertikale Partitionierung bedeutet, dass jeder Mandant über eine andere Datenbank (und Datenbankverbindungszeichenfolge) verfügt.
Standardmäßig stellt Flask-BDA eine Verbindung zu einem Mandanten namens
defaulther. Dies erfolgt mithilfe desSQLALCHEMY_BINDSObjekts (inconfig.pyzu finden), das über die spezifischen Verbindungsdetails verfügen sollte, die Sie für jeden Mandanten benötigen. Die Standardverbindungsdetails werden in einer Zeichenfolge namensSQLALCHEMY_DATABASE_URIzusammengefasst, die eine schnelle und einfache Einrichtung eines einzelnen Mandanten ermöglichen soll.
Sie können dieselbe Struktur verwenden. Um jedoch mehrere Mandanten zu haben, können Sie diese schnell zum
SQLALCHEMY_BINDSObjekt hinzufügen. Um einen neuen Mieter hinzuzufügen, gehen Sie einfach wie folgt vor:
SQLALCHEMY_BINDS -Objekt eine neue Zeile mit dem Namen des Mandanten und den Details der Verbindungszeichenfolge SQLALCHEMY_BINDS = {
"default" : SQLALCHEMY_DATABASE_URI ,
"client1" : 'sqlite:///databases/sqlite/client1.db' ,
}Sie können jetzt mit einer isolierten Mandantendatenbank interagieren, indem Sie das Argument
organization=zu Ihrer URL hinzufügen, z. B.:example.com?organization=client1wobeiclient1der Name ist, den Sie imSQLALCHEMY_BINDSObjekt hinzugefügt haben.
Dies funktioniert durch das Abfangen von
@app.before_requestinapp/_init_.pyund das Ändern der Datenbank-Engine-Bindung mithilfe vondb.choose_tenant(g.organization)ausapp/mod_tenancy/multi_tenant.pymithilfe der globalen Variableng.organization, die abgerufen wird Wird durch Abrufen des URL-Argumentsorganizationfestgelegt. Dadurch kann derselbe Code in der App von der Datenbank jedes Mieters verwendet werden, während die Daten getrennt bleiben.
Manchmal müssen Sie in einer einzigen Funktion mit verschiedenen Datenbanken interagieren (insbesondere bei der Integration von Systemen oder beim Lesen von Daten aus verschiedenen Quellen).
Standardmäßig wird auf allen Controllern
MultiBindSQLAlchemyimportiert.
# import multiple bindings
from app . mod_tenancy . multi_bind import MultiBindSQLAlchemyUnter dem Import befindet sich auskommentierter Code, der Ihnen dabei helfen soll, die Verknüpfung zu verschiedenen Datenbanken schnell in einer einzigen Funktion zu implementieren. Zunächst muss die Datenbankbindung zum
SQLALCHEMY_BINDS-Objekt hinzugefügt werden. Verweisen Sie auf die isolierten Datenbanken mit derselben Funktionalität, um besser zu verstehen, wie neue Datenbanken zumSQLALCHEMY_BINDS-Objekt hinzugefügt werden.
Anschließend können Sie ein neues Objekt erstellen, das an das
dbangehängt ist und dabei der Struktur vondb.<binding>folgt, z. B.:db.firstwobeifirstder Name ist, auf den Sie im Rest des Codes auf die Bindung verweisen möchten. Sie können diese Variable dann derMultiBindSQLAlchemyzuweisen, z. B.:db.first = MultiBindSQLAlchemy('first').
Dadurch können Sie jetzt benutzerdefinierten Code aufrufen, der Ihnen den Zugriff auf die neue Datenbankbindung sowie den Hauptmandanten in einer einzigen Funktion ermöglicht, z. B.
db.first.execute(...), wo Sie rohen SQL-Code ausführen können.
db . first = MultiBindSQLAlchemy ( 'first' )
##################################################
## this will only work for the execute function ##
##################################################
db . first . execute (...)**Hinweis: ** Dies funktioniert nur für die
execute. Es gibt einige fortgeschrittene Techniken, um weiterhin den SQLAlchemy ORM zu verwenden, die hier zu finden sind: SQLAlchemy-Ausführungs-Tutorial
Ein Modul ist eine eigenständige Komponente und lässt sich daher einfacher verwalten, wenn das Programm wächst. Module in Flask-BDA helfen Ihnen bei der Erstellung: eines Datenmodells, Routen und zugehöriger Funktionen zur Steuerung der Logik und Ansichten.
Wenn Sie ein neues CRUD-Modul erstellen, werden alle Elemente aus dem Ordner
create_module_templatein das App-Verzeichnis kopiert und in den von Ihnen angegebenen Modulnamen umbenannt, indem allexyzWerte durch Ihren Modulnamen ersetzt und zusätzliche Datenmodellinformationen hinzugefügt werden, wie unten beschrieben
<Path To>/<my_awesome_project>/create_module_json.py<Path To>/<my_awesome_project>/ der Pfad zu dem von Ihnen erstellten Projekt cd < Path To > / < my_awesome_project > /
python create_module_json . py - - module = Projects Create new field Name (type the string : 'STOP_CREATING_FIELDS' to exit ): "name"
What datatype is name
Choose one of the following options
( 'String'
, 'Int'
, 'Float'
, 'Numeric'
, 'Text'
, 'Date'
, 'DateTime'
, 'Boolean'
, 'BigInt'
, 'Enum'
, 'JSON'
, 'LargeBinary' ): "String"
String Length ( 1 - 256 ): 256
Is name nullable ( 'True' , 'False' ): False
Is name unique ( 'True' , 'False' ): True
Does the name have a Relationship with another Data Model ? ( 'True' , 'False' ): False
Default value : Hinweis: Dies wird so lange wiederholt, bis Sie die genauen Wörter eingeben und übermitteln: „STOP_CREATING_FIELDS“.
Dadurch können Sie schnell und einfach mehrere Felder für Ihr Modul erstellen.
Die obigen Felder sollten zeigen, dass Sie mit verschiedenen Feldtypen interagieren und mehrere Felder erstellen.
Hinweis: Beziehungen werden immer auf der
iddes angegebenen Modells hergestellt.Für das Feld wird ein ForeignKey sowie eine Lazy-Beziehung zwischen dem vom Modell bereitgestellten
id-Feld erstellt
Create new field Name (type the string : 'STOP_CREATING_FIELDS' to exit ): STOP_CREATING_FIELDS Create module logic from Data Model ? ( 'True' , 'False' ): TrueHinweis: Sie können ein Modul auch aus einer JSON-Datei in „app/generated_config/models//models.json“ generieren. Dabei ist der Name des Moduls, das Sie eingeben. Dazu können Sie die Datei öffnen und ausführen:
<Path To>/<my_awesome_project>/create_module.py* Wobei<Path To>/<my_awesome_project>/der Pfad zu dem von Ihnen erstellten Projekt ist * Geben Sie die Anweisungen ein, z. B.:
cd < Path To > / < my_awesome_project > /
python create_module . py - - module = projectsDadurch werden dann die erforderlichen Dateien und Ordner erstellt, wie unten in den App-Änderungen beschrieben
Dateien und Ordner aus dem Ordner
create_module_templatewerden für dasProjectserstellt und dann demapp-Ordner hinzugefügtDadurch werden gegerüstete Admin-CRUD-Ansichten, eine REST-API (mit Masseneinfügung und -aktualisierung), eine GraphQL-API sowie öffentlich zugängliche Ansichten und Logik erstellt, damit Sie sofort mit dem von Ihnen erstellten Modul interagieren können.
Im Admin-Bereich können Sie die folgenden Aktionen ausführen: Erstellen, Lesen, Aktualisieren und Löschen („CRUD“) für Ihr neues Modul.
Die öffentlichen Ansichten ermöglichen es Gastbenutzern (nicht angemeldeten Benutzern), eine Ansicht der bereitgestellten Informationen anzuzeigen
└── `my_awesome_project`
└── app
├── generated_config
│ └── models
│ └── `projects`
│ └── models.json
└── `mod_projects`
├── templates
│ ├── mobile
│ │ └── `projects`
│ │ ├── admin
│ │ │ ├── create.html
│ │ │ ├── edit.html
│ │ │ ├── index.html
│ │ │ └── show.html
│ │ └── public
│ │ └── public_list.html
│ └── `projects`
│ ├── admin
│ │ ├── create.html
│ │ ├── edit.html
│ │ ├── index.html
│ │ └── show.html
│ └── public
│ └── public_list.html
├── api_controllers.py
├── controllers.py
├── forms.py
├── models.py
└── types.py
Durch das Erstellen eines neuen Moduls stehen Ihnen drei Möglichkeiten zur Interaktion mit Ihrem neuen System zur Verfügung:
Public,Admin,REST APIundGraphQL API.
Um darauf zugreifen zu können, muss die App in einer Umgebung ausgeführt werden.
Die
PublicAnsicht ist eine nicht authentifizierte Ansicht der im Modul bereitgestellten Daten.
xyz der Name des Moduls ist):../xyz/public_list Die
AdminAnsichten sind authentifizierte Ansichten der im Modul bereitgestellten Daten.
xyz der Name des Moduls ist):../admin/xyz/index../admin/xyz/createcreate../admin/xyz/storestore../admin/xyz/show/{id}show../admin/xyz/edit/{id}edit../admin/xyz/update/{id}update../admin/xyz/destroy/{id}destroy Bei den
APIAnsichten handelt es sich um eine Liste von REST-API-Endpunkten, zugehöriger Dokumentation und einem Ausführungsspielplatz.
Flask BDA verwendet SwaggerUI, um einem Benutzer/Client die REST-API zu präsentieren.
Mit SwaggerUI kann jeder – sei es Ihr Entwicklungsteam oder Ihre Endverbraucher – die Ressourcen der API visualisieren und mit ihnen interagieren, ohne dass die Implementierungslogik vorhanden ist. Stattdessen wird es automatisch aus Ihrer OpenAPI-Spezifikation (früher bekannt als Swagger) generiert, mit visueller Dokumentation, die die Back-End-Implementierung und den clientseitigen Verbrauch erleichtert.
So greifen Sie auf die SwaggerUI zu:
<base_URL>/api/docs ein, um auf die SwaggerUI REST API zuzugreifen, z. B.: http://localhost:5000/api/docs .So greifen Sie ohne SwaggerUI auf die REST-API zu:
<base_URL>/ ein.../api/xyzXyzListResource > get../api/xyzXyzListResource > post../api/xyz/{id}XyzResource > get../api/xyz/{id}XyzResource > update../api/xyz/{id}XyzResource > delete../api/xyz/bulkXyzBulkListResource > post../api/xyz/bulkXyzBulkListResource > update../api/xyz/aggregateXyzAggregateResource > get Die
graphqlAnsichten sind GraphiQL-Ansichten, API-Endpunkte, zugehörige Dokumentation und Ausführungsspielplatz.
Flask BDA verwendet Graphene-Python und GraphiQL, um einem Benutzer/Client die GraphQL-API zu präsentieren und stellt so eine einfache, aber erweiterbare API bereit, die das Leben von Entwicklern einfacher macht.
GraphQL ist eine Datenabfragesprache, die eine Alternative zu REST und Ad-hoc-Webservice-Architekturen bietet.
So greifen Sie auf GraphiQL zu:
<base_URL>/graphql ein, um auf die GraphiQL- und GraphQL-API zuzugreifen, z. B.: http://localhost:5000/graphql .So greifen Sie ohne GraphiQL auf die GraphQL-API zu:
<base_URL>/ ein.../graphqlmod_graphql > query > Query > all_xyz../graphqlmod_graphql > mutation > Mutation > createXyz Derzeit werden 7 sofort einsatzbereite Umgebungen unterstützt (weitere sollen bald unterstützt werden) mit Anweisungen zur jeweiligen Konfiguration für Windows / Linux / Mac . Sie können sie bei Bedarf auch gleichzeitig ausführen.
Um eine lokale Anwendung zu erstellen und zu entwickeln, verwenden wir Virtualenv. Ein Tool zum Erstellen isolierter virtueller Python-Umgebungen.
pip install --upgrade pip auszuführencd <Path To>/my_awesome_project ausführen cd < Path To > /my_awesome_project
pip install --upgrade pip
pip install virtualenv
virtualenv venv
venv S cripts a ctivate
pip install --upgrade pip
pip install --no-cache-dir -r requirements.txt
set FLASK_APP=app
set FLASK_ENV=development
flask run --port 5000
pip install --upgrade pip auszuführensudo aus, z. B.: sudo pip install --upgrade pip cd < Path To > /my_awesome_project
pip install --upgrade pip
pip install virtualenv
virtualenv venv
source venv/bin/activate
pip install --upgrade pip
pip install --no-cache-dir -r requirements.txt
export FLASK_APP=app
export FLASK_ENV=development
flask run --port 5000
Einige Shared-Hosting-Dienste bieten die Möglichkeit, Python-Anwendungen auf ihren Servern auszuführen. Ich persönlich habe A2hosting verwendet. Ihr Support war großartig und das Preis-Leistungs-Verhältnis ist eines der besten, die ich je gesehen habe.
Hinweis: Sie sind nicht auf A2 als Shared-Hosting-Option beschränkt. Hier habe ich jedoch Flask-BDA getestet und habe meine Erfahrung beim Hochladen und Betreiben einer Shared-Hosting-Option. Wenn Ihre Shared-Hosting-Option ähnliche Funktionen bietet, können Sie diese gerne nutzen.
Für A2 müssen Sie Ihren Server so einrichten, dass er eine Python-Anwendung ausführt, was beispielsweise einige Konfigurationen erfordern kann.
Damit Ihre benutzerdefinierte Anwendung funktioniert:
Hinweis: In einer
LinuxUmgebung funktioniert die Anforderungpyodbcstandardmäßig nicht. Aus diesem Grund und da es sich um eine gemeinsam genutzte Umgebung handelt, verfügen Sie möglicherweise nicht über die Rechte, die Anforderungen hinzuzufügen, damit die Installation funktioniert. Der einfachste Weg, um sicherzustellen, dass die Installation nicht fehlschlägt, besteht darin, diese Anforderung auf dem Server auskommentieren.
requirements.txt , suchen Sie nach pyodbc und geben Sie vor dem Paketnamen ein # mit einem Leerzeichen ein. # pyodbc==4.0.30
requirements.txt .SSH Fenster ausführen, in dem Sie sich im vorherigen Schritt angemeldet haben pip install --upgrade pip
pip install --no-cache-dir -r requirements.txt
Setup Python AppApplication startup file in run_shared_server.pyZum Erstellen und Bereitstellen einer Containeranwendung verwenden wir Docker, das Entwicklern und Entwicklungsteams beim Erstellen und Versenden von Apps hilft. Darüber hinaus wird Docker zum Erstellen und Teilen von Containeranwendungen und Microservices verwendet.
Hinweis: Wenn Sie Github verwenden und Docker installiert haben (Details zur Installation finden Sie später in der Dokumentation), wird bei jedem
pushoderpull_requestauf Github ein neues Image erstellt, das in der Dateidocker-image.ymleingerichtet wirddocker-image.ymlWenn Sie dies jedoch manuell tun möchten, führen Sie bitte die folgenden Schritte aus:
cd < Path To > /my_awesome_project
docker build -t flask_app:latest .
docker run -p 5000:5000 flask_app
curl -fsSL https://get.docker.com -o get-docker.sh
sh get-docker.sh
systemctl start docker
cd < Path To > /my_awesome_project
docker build -t flask_app:latest .
docker run -it -p 5000:5000 flask_app
Hinweis: Noch in der Entwicklung
Um eine serverlose Anwendung zu erstellen und bereitzustellen, verwenden wir das Serverless Framework, das eine reibungslose serverlose Entwicklung ermöglicht und Ihnen die einfache Erstellung von Apps ermöglicht, die automatisch auf einer kostengünstigen Cloud-Infrastruktur der nächsten Generation skaliert werden.
Das Serverless-Framework ist ein Open-Source-Tool, das eine einfache YAML + CLI-Entwicklung und Bereitstellung für AWS, Azure, Google Cloud, Knative und mehr ermöglicht.
Hinweis: Möglicherweise müssen Sie die Standard-Datenbankzeichenfolgen vor del=polying anpassen, da Serverless „SQLite“ nicht unterstützt, da die Funktion den Status nicht beibehält.
Informationen zum Aktualisieren der Datenbankzeichenfolgen finden Sie unter [Config]
npm update -g serverless
npm update -g serverless
choco install serverless
Hinweis: Wenn das Paket nicht installiert wird, müssen Sie den Befehl möglicherweise als Administrator ausführen.
Drücken Sie die „Windows-Taste“, geben Sie „cmd“ ein, klicken Sie mit der rechten Maustaste auf das Wort „Eingabeaufforderung“, wählen Sie die Option „Als Administrator ausführen“ und befolgen Sie dann die vorherigen Schritte erneut
serverless
cd < Path To > /my_awesome_project
sls plugin install -n serverless-python-requirements
sls plugin install -n serverless-wsgi
serverless deploy
curl -o- -L https://slss.io/install | bash
curl -fsSL https://get.docker.com -o get-docker.sh
sh get-docker.sh
systemctl start docker
cd < Path To > /my_awesome_project
sls plugin install -n serverless-python-requirements
sls plugin install -n serverless-wsgi
serverless deploy
Hinweis: Noch in der Entwicklung
Digital Ocean ist eine Plattform as a Service (PaaS). Entwickeln, verwalten und skalieren Sie Ihre Anwendungen auf der vollständigen Cloud-Plattform von DigitalOcean. Digital Ocean bietet Ihnen eine einfache, vorhersehbare Preisgestaltung. Erstellen und veröffentlichen Sie sicher mit skalierbaren Rechenprodukten in der Cloud, vollständig verwalteten Datenbanken, hochverfügbaren und skalierbaren Speicheroptionen und mehr. Mit virtuellen Maschinen mit ausreichend Arbeitsspeicher, die auf das Hosten und Skalieren von Anwendungen und Datenbanken abgestimmt sind, bietet Digital Ocean einfache Lösungen für komplexe Probleme.
Um vom Terminal aus eine Anwendung für Heroku zu erstellen und bereitzustellen, müssen Sie Folgendes tun:
138.197.67.25HINWEIS: Wenn Sie keine Verbindung über SSH hergestellt haben, sollten Sie das
passwordüber die E-Mail-Adresse erhalten, mit der Sie das Konto für Digital Ocean registriert haben.
cd < Path To > / < my_awesome_project > /
scp -r < my_awesome_project > root@ < ip_address > :/
ssh root@ < ip_address >
Dabei ist
<Path To>/<my_awesome_project>/der Pfad zu dem von Ihnen erstellten Projekt und<ip_address>die Droplets <ip_address>, z. B.:138.197.67.25
HINWEIS: Befolgen Sie alle Eingabeaufforderungen, die im SSH vorgelegt wurden, z. B. den Zugriff vom Remote -Server zuzulassen.
Sobald Sie angemeldet sind, sollten Sie in der Lage sein, ein Terminal mit:
root@ < droplet_name > :
cd < Path To > / < my_awesome_project > /
chmod +x setup.sh
bash setup.sh
virtualenv venv
source venv/bin/activate
sudo pip install --upgrade pip
sudo pip install --no-cache-dir -r requirements.txt
sudo pip install uwsgi
sudo ufw allow 5000
export FLASK_APP=app
uwsgi --socket 0.0.0.0:5000 --protocol=http -w wsgi:app
Wobei
5000die Portnummer ist
und<droplet_name>ist der Name
cd < Path To > / < my_awesome_project > /
scp -r < my_awesome_project > root@ < ip_address > :/
ssh root@ < ip_address >
Wobei
<Path To>/<my_awesome_project>/der Pfad zu dem von Ihnen erstellten Projekt ist und wo<ip_address>die Tröpfchen <ip_address> zB:138.197.67.25ist
HINWEIS: Befolgen Sie alle Eingabeaufforderungen, die im SSH vorgelegt wurden, z. B. den Zugriff vom Remote -Server zuzulassen.
Sobald Sie angemeldet sind, sollten Sie in der Lage sein, ein Terminal mit:
root@ < droplet_name > :
cd < Path To > / < my_awesome_project > /
chmod +x setup.sh
bash setup.sh
virtualenv venv
source venv/bin/activate
sudo pip install --upgrade pip
sudo pip install --no-cache-dir -r requirements.txt
sudo pip install uwsgi
sudo ufw allow 5000
export FLASK_APP=app
uwsgi --socket 0.0.0.0:5000 --protocol=http -w wsgi:app
Wobei
5000die Portnummer ist
und<droplet_name>ist der Name
HINWEIS: Noch in der Entwicklung
Heroku ist eine Plattform als Service (PAAS). Mit Heroku können Sie mit kein Engagement beginnen, zahlen, wenn Sie ohne Sperren gehen. Entwickler, Teams und Unternehmen aller Größen können Heroku verwenden, um Apps bereitzustellen, zu verwalten und zu skalieren. Unabhängig davon, ob Sie einen einfachen Prototyp oder ein geschäftskritisches Produkt aufbauen, bietet Ihnen Herokus voll verwaltete Plattform einen einfachen Weg, um Apps schnell zu liefern.
Um eine Anwendung aus dem Terminal aus Heroku zu erstellen und bereitzustellen, müssen Sie die Heroku CLI herunterladen und installieren. Um die Installation zu überprüfen, können Sie die Heroku -Version aus dem Terminal überprüfen:
heroku --version
Hinweis: Stellen Sie sicher, dass Sie Ihre Datenbankverbindung geändert haben, da Heroku nicht vorschlägt, SQLite zu verwenden, da die Daten möglicherweise in den Dateien verloren gehen. Heroku bietet eine kostenlose Postgres -Datenbank an. Sehen Sie sich ihre Pläne an und wählen Sie den richtigen Plan für Sie, da die verschiedenen Pläne Grenzen haben.
cd < Path To > /my_awesome_project
heroku login
<my_awesome_project-flask-bda-app> , wobei <my_awesome_project-flask-bda-app> der Name ist, den Sie Ihrem Projekt angegeben haben.heroku create my_awesome_project-flask-bda-app
git push heroku master
<my_awesome_project-flask-bda-app> der Name ist, den Sie Ihrem Projekt gegeben haben. cd < Path To > /my_awesome_project
sudo snap install --classic heroku
heroku login
<my_awesome_project-flask-bda-app> , wobei <my_awesome_project-flask-bda-app> der Name ist, den Sie Ihrem Projekt angegeben haben.heroku create my_awesome_project-flask-bda-app
git push heroku master
<my_awesome_project-flask-bda-app> der Name ist, den Sie Ihrem Projekt gegeben haben. cd < Path To > /my_awesome_project
brew tap heroku/brew && brew install heroku
heroku login
<my_awesome_project-flask-bda-app> , wobei <my_awesome_project-flask-bda-app> der Name ist, den Sie Ihrem Projekt angegeben haben.heroku create my_awesome_project-flask-bda-app
git push heroku master
<my_awesome_project-flask-bda-app> der Name ist, den Sie Ihrem Projekt gegeben haben. Für native mobile Apps verwenden wir React-Native. Insbesondere verwenden wir Expo als Framework und Plattform für universelle React -Anwendungen. Es handelt sich um eine Reihe von Tools und Diensten, die auf reag -nativen und nativen Plattformen basieren, mit denen Sie auf iOS-, Android- und Web -Apps aus demselben JavaScript/TypeScript -Codebasis entwickelt, erstellt, bereitgestellt und schnell iterieren.
Wir haben Push-Benachrichtigungen vor dem Sett, also müssen Sie es nicht. Dies bedeutet, dass es für Sie schneller und leichter ist, loszulegen und zu laufen. Darüber hinaus nutzen wir das Standardpaket für Expo-Notifikationen, das eine vereinfachte Implementierung und einen vereinfachten Ansatz ermöglicht.
Zu den Vorteilen gehören schnellere Erstellung und Test -Workflows/-prozesse, Fernuntersuchungen während der Entwicklung mit Over -the Air (OTA) -Atualisierungen mit Änderungen, die beim Sparen während der Entwicklung sichtbar sind.
Es gibt jedoch einige Nachteile, und die Einschränkungen sind sich dessen bewusst und beschreiben sie recht gut. Wir empfehlen, diese Einschränkungen zu überprüfen, bevor wir unsere vorgefertigte Methode verwenden.
Erstellen Sie ein Projekt, das nativ auf allen Geräten Ihrer Benutzer ausgeführt wird.
cd < Path To > /my_awesome_project_mobile_app
npm install -g expo-cli
npm install
cd < Path To > /my_awesome_project_mobile_app
npm install -g expo-cli
npm install
Da Flask BDA nicht vorschreibt, wo Sie Ihre Website hosten sollten, müssen Sie Ihre mobile App mitteilen, wohin Sie gehen sollen.
Im QuickStart -Beispiel haben wir ein Projekt namens
"My Awesome Project"erstellt. Möglicherweise haben Sie das Projekt jedoch etwas anderes bezeichnet. Dies hätte einen Ordner erstellt, in dem der Name in Lower Case ist, alle Sonderzeichen ausgestattet und Räume durch Unterstriche ersetzt, z. B.my_awesome_project.
Für Mobilgeräte haben wir automatisch einen separaten
"_mobile_app"-Fordner erstellt, in dem das Präfix des Ordners Ihr Projektname ist, z. B.my_awesome_project_mobile_app. Dies soll Probleme mit demServerlesspackage.jsonverhindern und es Ihnen ermöglichen, nicht den gesamten Code für eine mobile App auf Ihrem Webserver bereitzustellen.
Wenn Sie sich noch in der Entwicklung befinden und/oder noch keinen Dienstanbieter für das Hosting ausgewählt haben, können Sie: NGROK verwenden, um eine vorübergehende URL der öffentlichen Entwicklung zu erstellen, die Tunnel für Ihre lokale Umgebung erstellt. Ngrok setzt lokale Server hinter Nats und Firewalls dem öffentlichen Internet über sichere Tunnel aus. Auf diese Weise können Sie auf einer öffentlichen URL -Websites auf dem Vorbeigehen auf mobile Apps, die mit Ihrem lokal laufenden Backend angeschlossen sind, ohne Bereitstellung testen.
Starten Sie den lokalen Entwicklungsserver, indem Sie die lokalen Umgebungsanweisungen befolgen
Wenn Sie sich vorher nicht für NGROK registriert haben:
Wenn Sie bereits registriert sind, aber nicht installiert sind:
Sobald das NGROK -Terminal geöffnet ist, erstellen Sie einen Tunnel von Ihrem lokalen Server nach NGROK
5000 geändert haben, ersetzen Sie die Nummer nach http damit der richtige Tunnel erstellt werden kann. ngrok http 5000
ngrok by @inconshreveable
(Ctrl+C to quit)
Session Status online
Session Expires 1 hour, 59 minutes
Version 2.3.40
Region United States (us)
Web Interface http://127.0.0.1:4040
Forwarding http://573d4ec93267.ngrok.io - > http://localhost:5000
Forwarding https://573d4ec93267.ngrok.io - > http://localhost:5000
Connections
ttl opn rt1 rt5 p50 p90
0 0 0.00 0.00 0.00 0.00
HINWEIS: Die kostenlose Version hält diesen Server nur 2 Stunden lang am Leben, sodass Sie diesen Prozess möglicherweise in Zukunft befolgen müssen. Wenn Sie diese URL zu Ihrem "Repo" schieben, funktioniert sie möglicherweise nicht für die nächste Person.
my_awesome_project_mobile_appapp.json und bearbeiten Sie Zeile 2 "server_base_url": "https://github.com/RyanJulyan/Flask-BDA" https://github.com/RyanJulyan/Flask-BDA indem Servername.expo -App auf Ihrem eigenen Mobiltelefon, indem Sie im Apple- oder Google Play Store nach "Expo" suchen:iOS gehen Sie zu: https://apps.apple.com/app/apple-store/id982107779Android gehen zu: https://play.google.com/store/apps/details?id=host.exp.exponentSobald die App auf Ihrem Telefon installiert ist, können Sie einen Entwicklungsserver auf Ihrem lokalen Computer starten.
cd < Path To > /my_awesome_project_mobile_app
expo start
cd < Path To > /my_awesome_project_mobile_app
expo start
Dadurch wird eine Webseite mit einem QR -Code geöffnet. Auf diese Weise können Sie die Expo -App verwenden, wenn Sie auf Android sind oder die Kamera verwenden, wenn Sie auf iOS sind, um den Code zu scannen und Ihre App direkt über den Entwicklungsserver zu öffnen.
HINWEIS: Wenn Sie möchten, dass Personen in Ihrem Netzwerk nicht in der Lage sein, die App remote zu scannen und zu testen, drücken Sie die Registerkarte
tunnelüber dem QR -Code.
Ein Teil der Empfehlungen besteht darin, sicherzustellen, dass die Bilder optimiert werden. Zu dieser Expo wurde das Expooptimize-Paket empfohlen, mit dem die Optimierung der Bilder helfen können. Darüber hinaus kann das Optimieren von Bildern Ihre native App TTI (oder Zeit-zu-Interaktion) verbessern, was weniger Zeit auf Begrüßungsbildschirmen und schnellere Lieferung über schlechte Netzwerkverbindungen bedeutet.
cd < Path To > /my_awesome_project_mobile_app
npm install -g sharp-cli
npx expo-optimize --quality 0.9
cd < Path To > /my_awesome_project_mobile_app
npm install -g sharp-cli
npx expo-optimize --quality 0.9
Um eine Desktop -Anwendung zu erstellen und zu entwickeln, verwenden wir Flaskwebgui. Ein Tool zum Erstellen und Ausführen Ihrer Flask -Webanwendung in einem Chrome -Wrapper. Um die Desktop -Anwendung zu verteilen, verwenden wir PyInstaller. PyInstaller friert (Pakete) Python-Anwendungen in eigenständige ausführbare Ausführbarungen unter Windows, Gnu/Linux, Mac OS X, FreeBSD, Solaris und AIX.
Jede Bereitstellung muss auf der spezifischen Plattform erstellt werden, die Sie ausführen möchten. Wir haben Skripte erstellt, mit denen Sie diese Bereitstellungen verwalten können, indem Sie die
buildunddist-Ordner für die jeweilige Plattform in übergeordnete Ordner platzieren. Diese Ordner werden mitdesktop_gefolgt von der Plattform vorangestellt. Dies geschieht nur, damit Sie die Verteilung verwalten und Prozesse für die spezifischen Plattformen erstellen und sie nicht überschreiben können, wenn Sie auf verschiedenen Plattformen aufbauen.
Um den Export auf den Desktop richtig zu ermöglichen, benötigen wir einige Codeänderungen. Standardmäßig ist Flask-BDA für Web- und Mobileentwicklung vorgesehen, und wir haben einen Ratenlimiter auf der Website implementiert. Leider benötigen Sie einen Server, um das Grenzwert zu bewerten, und da Sie das System in eine Desktop -Anwendung exportieren, wird kein Server ausgeführt.
Daher müssen Sie alle Verweise auf den Limiter entfernen. Diese finden Sie bei
app/__init__.py. Öffnen Sie dazu die Datei in einem Texteditor und kommentieren Sie die folgenden Zeilen:
# from flask_limiter import Limiter
# from flask_limiter.util import get_remote_address
# limiter = Limiter(
# app,
# key_func=get_remote_address,
# default_limits=app.config['DEFAULT_LIMITS']
# )Hinweis: Wenn Sie einen benutzerdefinierten Limiter hinzugefügt haben, suchen Sie nach
@limiter.limit, der in Ihren Controllern zu finden ist. Sie müssen alle diese Referenzen und die Importreferenzen, z. B.from app import limiter
Auf diese Weise können Sie die Anwendung als ausführbare Desktop -Datei ohne Fehler exportieren.
pip install --upgrade pip auszuführencd <Path To>/my_awesome_project ausgeführt werden cd < Path To > /my_awesome_project
pip install --upgrade pip
pip install virtualenv
virtualenv venv
venv S cripts a ctivate
pip install --upgrade pip
pip install --no-cache-dir -r requirements.txt
python create_desktop_installer_windows.py
pip install --upgrade pip auszuführensudo pip install --upgrade pip als sudo z. cd < Path To > /my_awesome_project
pip install --upgrade pip
pip install virtualenv
virtualenv venv
source venv/bin/activate
pip install --upgrade pip
pip install --no-cache-dir -r requirements.txt
python create_desktop_installer_lunix.py
pip install --upgrade pip auszuführensudo pip install --upgrade pip als sudo z. cd < Path To > /my_awesome_project
pip install --upgrade pip
pip install virtualenv
virtualenv venv
source venv/bin/activate
pip install --upgrade pip
pip install --no-cache-dir -r requirements.txt
python create_desktop_installer_mac.py
Dadurch wird ein maximiertes Fenster geöffnet, das wie eine normale Desktop -Anwendung ausgeführt wird. Dadurch wird der lokal installierte Chrome -Browser zum Servieren des Inhalts verwendet.
Standardmäßig wird diese Anwendung auf Port
7000zugestellt. Sie können den Port jedoch in der Dateirun_desktop.pybearbeiten, wenn dies mit vorhandenen Anwendungen in Konflikt steht.
Wenn Sie zusätzliche Python -Pakete in Ihr Projekt aufnehmen, vergessen Sie nicht,
pip freezevon Ihrem Terminal auszuführen, um sicherzustellen, dass Sie die richtigen Pakete für Ihre Bereitstellungen erhalten
pip freeze > requirements.txt
Hinweis: Es wird vorgeschlagen, zusätzliche Python -Pakete aus einer virtuellen Umgebung und nicht global zu installieren und einzufrieren. Dies hält Ihre
requirements.txtan.
Flask BDA verwendet standardmäßig Swaggerui, um die API einem Benutzer/Client zu unterstützen und zu präsentieren.
Swaggerui ermöglicht es jedem - sein Entwicklungsteam oder Ihre Endverbraucher - die Ressourcen der API zu visualisieren und mit einer der Implementierungslogik zu interagieren. Stattdessen wird es automatisch aus Ihrer OpenAPI-Spezifikation (früher als Swagger bekannt) generiert. Visuelle Dokumentation erleichtert die Back-End-Implementierung und den Kundenverbrauch.
Zugang zu Swaggerui:
<base_URL>/api/docs ein, um auf die Swaggerui -API zuzugreifen, z. B. http://localhost:5000/api/docsViele Entwickler bevorzugen Postboten gegenüber Swaggerui, um APIs in ihren Code zu testen und zu integrieren. Wir haben unterstützt, indem wir einen direkten Sammelexport für Postbote bereitgestellt haben.
Um die Sammlung auf Postboten zu importieren:
Import... (Strg+O)Link aus den Registerkarten<base_URL>/api/postman ein, z http://localhost:5000/api/postman<base_URL>/aswagger.json EG: http://localhost:5000/swagger.json und importieren Sie das direkt in Postmanhttps://learning.postman.com/docs/getting-started/importing-and-exporting-data/#converting-postman-collections-from-v1-to-v2 die Datei von v1 in v2 zu konvertieren https://learning.postman.com/docs/getting-started/importing-and-exporting-data/#converting-postman-collections-from-v1-to-v2 npm install -g postman-collection-transformer
postman-collection-transformer convert -i <path to the input Postman collection file> -o <path to the downloaded Postman file> -j 1.0.0 -p 2.0.0 -P
<path to the input Postman collection file> und <path to the downloaded Postman file> physische Dateipfade auf Ihrem lokalen Computer sind.ContinueImportDadurch wird eine Postman-Sammlung importiert, die als Ordner links als Ordner verfügbar wird (mit Unterordnern von jedem der von Ihnen erstellten Endpunkte).
Mit dem Postboten können Sie Code für viele verschiedene Lanuagen und Frameworks generieren. Diese Sprachen umfassen, sind aber nicht beschränkt auf:
So können Sie Ihre neu erstellte API in vorhandene Projekte integrieren
Manchmal müssen Sie externe Anfragen stellen (zB zu einer externen API). Sie können dies mit AJAX-Anfragen angehen, aber manchmal müssen Sie diese Anfragen von der serverseitig stellen, beispielsweise, wenn Sie Währungskonvertierungen automatisch aktualisieren möchten. Wenn Sie über den Server auf externe APIs zugreifen möchten, möchten Sie sich nicht darauf verlassen, dass sich ein Benutzer aktiv auf der Webseite befindet, um den Befehl zu senden. Stattdessen möchten Sie, dass der Server diesen Kommentar aktivieren kann. Um dies zu erreichen, verwenden wir das Anfragemodul.
import requests
requests . methodname ( params ) import requests
params = { "model" : "Mustang" }
x = requests . get ( 'https://w3schools.com/python/demopage.php' , params = params )
print ( x . status_code )
print ( x . text ) import requests
data = { "Name" : "Example" }
headers = { "Authorization" : "Bearer <token>" }
x = requests . post ( 'https://w3schools.com/python/demopage.php' , data = data , headers = headers )
print ( x . status_code )
print ( x . text ) import requests
import json
data = { "Name" : "Example" }
headers = { "Authorization" : "Bearer <token>" }
x = requests . post ( 'https://w3schools.com/python/demopage.php' , json = data , headers = headers )
print ( x . status_code )
print ( x . text )
# use this to load JSON returned as a python dictionary
return_data = json . loads ( x . text ) import requests
data = { "Name" : "Example" }
headers = { "Authorization" : "Bearer <token>" }
x = requests . put ( 'https://w3schools.com/python/demopage.php' , data = data , headers = headers )
print ( x . status_code )
print ( x . text ) import requests
import json
data = { "Name" : "Example" }
headers = { "Authorization" : "Bearer <token>" }
x = requests . put ( 'https://w3schools.com/python/demopage.php' , json = data , headers = headers )
print ( x . status_code )
print ( x . text )
# use this to load JSON returned as a python dictionary
return_data = json . loads ( x . text ) import requests
x = requests . delete ( 'https://w3schools.com/python/demopage.php' )
print ( x . status_code )
print ( x . text )AJAX-Anforderungen, in der Regel eine von (Browser-Client) in JavaScript gestellte HTTP-Anforderung, die mit XML/JSON Daten und/oder Antwortdaten entweder aus einem internen oder externen System anfordert. AJAX -Anforderungen werden standardmäßig mit </> HTMX mithilfe von </> HTMX gestellt.
HTMX ist eine abhängigenfreie Bibliothek, mit der Sie auf AJAX, CSS-Übergänge, Websockets und Server-Sent-Ereignisse direkt in HTML zugreifen können, um Attribute zu verwenden, damit Sie moderne Benutzeroberflächen mit der Einfachheit und Leistung des Hypertextes erstellen können. Weitere Informationen zur Verwendung von HTMX finden Sie in den Dokumenten und für eine vollständige Referenz zur Funktionalität finden Sie unter https://htmx.org/reference/.
Sie können HTMX verwenden, um viele gemeinsame UX -Muster zu implementieren, z. B. aktive Suche:
< input type =" text " name =" q "
hx-get =" /trigger_delay "
hx-trigger =" keyup changed delay:500ms "
hx-target =" #search-results "
placeholder =" Search... " />
< div id =" search-results " > </ div > Diese Eingabe mit dem Namen Q gibt eine Anforderung an /trigger_delay 500 Millisekunden nach einem Schlüssel-Up-Ereignis aus, wenn die Eingabe geändert wurde und die Ergebnisse mit den ID-Suchresistenz in die DIV einfügt.
Trotz der Vorteile der symmetrischen Verschlüsselung gibt es in dieser Methode einen Fehler, der es nicht autorisierte Personen ermöglicht, auf die geheimen Schlüssel einer Nachricht zuzugreifen.
Eine der effektivsten Möglichkeiten, den unbefugten Zugriff auf die geheimen Schlüssel einer Nachricht zu verhindern, besteht darin, eine Einweg-Funktion wie den Diffie-Hellman-Algorithmus implementieren zu können. Mit dieser Methode kann der Absender und der Empfänger die Nachricht entschlüsseln.
Einwegfunktionen werden normalerweise unter Verwendung eines Algorithmus-Typs implementiert, mit dem sie eine Ausgabe für jeden empfangenen Eingang berechnen können. Diese Methode ist jedoch nicht möglich, das genaue Ergebnis aus einem zufälligen Schlüssel abzuleiten.
Tests sind ein wesentlicher Bestandteil der erfolgreichen Ausführung eines Projekts
Es gibt 3 Aspekte des Tests in Flask BDA:
Hinweis: Stellen Sie sicher, dass Sie die lokalen Umgebungen installiert haben, um Python
unittestmanuell auszuführen
cd < Path To > /my_awesome_project
venv S cripts a ctivate
flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
flake8 . --count --exit-zero --max-complexity=11 --max-line-length=127 --statistics
cd < Path To > /my_awesome_project
source venv/bin/activate
flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
Hinweis: Stellen Sie sicher, dass Sie die lokalen Umgebungen installiert haben, um Python
unittestmanuell auszuführen
cd < Path To > /my_awesome_project
venv S cripts a ctivate
python -m unittest discover
cd < Path To > /my_awesome_project
venv/bin/activate
python -m unittest discover
Einzeldateiauslauf und Setup
Starterflaschenprojekt, das eine Projektordnerstruktur mit erstellt
992px500px@mobile_template , sodass Vorlagenansichten auf ein besseres mobiles Erlebnis zugeschnitten sind.{% if request.MOBILE %}True{% else %}False{% endif %}config.py für den schnellen Zugriff und die Verwaltung der Umgebungsvariablen und der Standard -SEOconfig.py Erstellen Sie benutzerdefinierte Moduldateien und Ordner, die aus der Datei create_module.py in die Flask -Projektstruktur passen, um die folgenden Eingabeaufforderungen zu erstellen:
public_listindexcreatestoreshoweditupdatedestroygetpostgetupdatedeletebefore und after Änderungen an einem Datenmodellereignis event listeners für:InsertUpdateDeletepublic_listindexcreatestoreshoweditupdatedestroygetpostgetupdate einsetzendeletepostupdategetpublic_list.html (Listenelemente)index.html (Listenelemente)create.html (einzelne Elementform)show.html (einzelnes Element)edit.html (Einzelelementform)api/docs (URL)Browserunterstützung (letzte 1 Hauptversion nicht tot)
└── `project_name`
├── .github
│ └── workflows
│ ├── docker-image.yml
│ └── run_tests.yml
├── app
│ ├── generated_config
│ │ ├── model_editor
│ │ └── models
│ │ ├── hierarchies
│ │ │ └── models.json
│ │ └── organisations
│ │ └── models.json
│ ├── mod_audit
│ │ ├── __init__.py
│ │ ├── controllers.py
│ │ └── models.py
│ ├── mod_users
│ │ ├── templates
│ │ │ ├── mobile
│ │ │ │ └── auth
│ │ │ │ ├── admin
│ │ │ │ │ ├── create.html
│ │ │ │ │ ├── edit.html
│ │ │ │ │ ├── index.html
│ │ │ │ │ └── show.html
│ │ │ │ └── public
│ │ │ │ └── public_list.html
│ │ │ ├── email
│ │ │ │ ├── activate.html
│ │ │ │ └── reset.html
│ │ │ └── users
│ │ │ ├── admin
│ │ │ │ ├── create.html
│ │ │ │ ├── edit.html
│ │ │ │ ├── index.html
│ │ │ │ └── show.html
│ │ │ └── public
│ │ │ └── public_list.html
│ │ ├── __init__.py
│ │ ├── controllers.py
│ │ ├── forms.py
│ │ └── models.py
│ ├── mod_email
│ │ ├── __init__.py
│ │ ├── controllers.py
│ │ └── models.py
│ ├── mod_file_upload
│ │ ├── templates
│ │ │ └── file_upload
│ │ │ └── upload.html
│ │ ├── __init__.py
│ │ ├── controllers.py
│ │ ├── forms.py
│ │ └── models.py
│ ├── static
│ │ ├── css
│ │ ├── images
│ │ ├── js
│ │ ├── manifest.json
│ │ └── sw.js
│ ├── templates
│ │ ├── admin
│ │ │ └── index.html
│ │ ├── email
│ │ │ └── auth
│ │ │ ├── activate.html
│ │ │ └── reset.html
│ │ ├── mobile
│ │ ├── public
│ │ │ └── index.html
│ │ ├── 403.html
│ │ ├── 404.html
│ │ └── index.html
│ └── __init__.py
├── create_module_template
│ ├── generated_config
│ │ └── models
│ │ └── xyz
│ │ └── models.json
│ └── mod_xyz
│ ├── templates
│ │ ├── mobile
│ │ │ └── xyz
│ │ │ ├── admin
│ │ │ │ ├── create.html
│ │ │ │ ├── edit.html
│ │ │ │ ├── index.html
│ │ │ │ └── show.html
│ │ │ └── public
│ │ │ └── public_list.html
│ │ └── xyz
│ │ ├── admin
│ │ │ ├── create.html
│ │ │ ├── edit.html
│ │ │ ├── index.html
│ │ │ └── show.html
│ │ └── public
│ │ └── public_list.html
│ ├── api_controllers.py
│ ├── controllers.py
│ ├── forms.py
│ └── models.py
├── databases
│ └── sqlite
│ ├── core.db
│ └── default.db
├── .dockerignore
├── .gitignore
├── config.py
├── create_all_models_json.py
├── create_desktop_installer_lunix.py
├── create_desktop_installer_mac.py
├── create_desktop_installer_windows.py
├── create_module.py
├── create_module_json.py
├── Dockerfile
├── FLASK-BDA LICENSE
├── LICENSE
├── package.json
├── package-lock.json
├── Procfile
├── README.md
├── requirements.txt
├── run.py
├── run_desktop.py
├── run_shared_server.py
└── serverless.yml
Ein Modul ist Teil eines Programms. Die Programme bestehen aus einem oder mehreren unabhängig entwickelten Modulen, die beim Kombination das Programm erstellen.
Ein Modul ist eine in sich geschlossene Komponente, die es einfacher macht, das Programm zu verwalten.
Module in Flask-BDA helfen Ihnen beim Erstellen: ein Datenmodell, Routen und zugehörige Funktionen zur Steuerung der Logik und Ansichten
Controller können zu einer einzigen Klasse zugehörigen Anforderungslogik gruppieren. Beispielsweise kann eine UserController -Klasse alle eingehenden Anfragen im Zusammenhang mit Benutzern behandeln, einschließlich der Anzeige, Erstellen, Aktualisierung und Löschen von Benutzern.
Erstellen, lesen, aktualisieren und löschen ("crud")
Die Linie ist die automatisierte Überprüfung Ihres Quellcodes für programmatische und stilistische Fehler. Dies geschieht mit einem Lint -Tool (auch als Linter bezeichnet). Ein Lint -Tool ist ein grundlegender statischer Codeanalysator.
Lint oder ein Linter ist ein statisches Code -Analyse -Tool, mit dem Programmierfehler, Fehler, stilistische Fehler und verdächtige Konstrukte angezeigt werden.
In der Computerprogrammierung sind Unit -Tests eine Software -Testmethode, mit der einzelne Einheiten von Quellcode - Sets eines oder mehrerer Computerprogrammmodule zusammen mit den zugehörigen Steuerungsdaten, Verwendungsverfahren und Betriebsverfahren - getestet werden, um festzustellen, ob sie für die Verwendung geeignet sind .
Eine Plattform mit niedriger Code-Entwicklung bietet eine Entwicklungsumgebung, um Anwendungssoftware über programmatische oder grafische Benutzeroberflächen und Konfigurationen anstelle herkömmlicher handkodierter Computerprogrammierung zu erstellen.
Wir würden uns freuen, wenn Sie auf eine oder alle dieser Arten zum Projekt beitragen würden:
Lizenzinformationen für Python anzeigen.
Lizenzinformationen für Docker anzeigen. (https://www.docker.com/legal/components-licenses) und andere rechtliche Vereinbarungen (https://www.docker.com/legal)
Wie bei allen Docker -Bildern enthalten diese wahrscheinlich auch andere Software, die unter anderen Lizenzen (z. B. Bash usw. aus der Basisverteilung zusammen mit direkten oder indirekten Abhängigkeiten der enthaltenen Primärsoftware) stehen.
Einige zusätzliche Lizenzinformationen, die automatisch zu erkennen sind, können im Python/ Verzeichnis des Repo-Info-Repositorys gefunden werden.
Bei jeder vorgefertigten Bildnutzung besteht die Verantwortung des Bildbenutzers darin, sicherzustellen, dass jede Verwendung dieses Bildes relevante Lizenzen für alle darin enthaltenen Software entspricht.
Lizenzinformationen für serverlose Framework und andere rechtliche Vereinbarungen anzeigen (https://app.serverless.com/legal/terms).
Es liegt in der Verantwortung des Benutzers, sicherzustellen, dass die Richtlinien für die akzeptable Nutzung einhalten (https://app.serverless.com/legal/aup).
Lizenzinformationen für das Expo -Framework und andere Rechtsvereinbarungen anzeigen (https://github.com/expo/expo/blob/master/license).
Flask-BDA wird unter der Entwickler-freundlichen Flask-BDA-Lizenz erstellt und verteilt. Die Flask-BDA-Lizenz wird aus der beliebten Apache 2.0-Lizenz abgeleitet.
Die Flask-BDA-Lizenz ist die gesetzliche Anforderung für Sie oder Ihr Unternehmen, Flask-BDA- und Derivatwerke wie die damit gestellten Anwendungen zu verwenden und zu verteilen. Ihre Bewerbung oder Ihr Projekt kann eine andere Lizenz haben, muss jedoch weiterhin die ursprüngliche Einhaltung einhalten.
Lizenz und Urheberrechtsbekanntmachung Inklusion
Die Flask-BDA-Lizenz verlangt, dass Sie die Lizenz und die Urheberrechtsbekanntmachung mit allen Kopien von Flask-BDA und in alle abgeleiteten Arbeiten mit Flask-BDA einbeziehen müssen. Es liegt an Ihnen, zu entscheiden, wie Sie die Lizenz und die Mitteilung verteilen möchten. Im Folgenden finden Sie einige Beispiele dafür, wie dies getan werden kann:
Copyright 2021 Flask-BDA, Ryan Julyan lizenziert im Rahmen der Flask-BDA-Lizenzversion 0.1 (die "Lizenz"); Sie dürfen keine Flask-BDA verwenden, außer in Übereinstimmung mit der Lizenz. Sie können eine Kopie der Lizenz unter https://github.com/RyanJulyan/Flask-BDA/blob/main/LICENSE erhalten, es sei denn Wie "Grundlage, ohne Gewährleistungen oder Bedingungen jeglicher Art, entweder ausdrücklich oder impliziert. Siehe die Lizenz für die spezifischen Sprachberechtigungen und Einschränkungen im Rahmen der Lizenz.
