1
from flask import Flask, render_template, request, redirect, url_for, session, jsonify, send_from_directory
2
from flask_sqlalchemy import SQLAlchemy
3
import hashlib
4
import js2py
5
import os
6
import json
7

8
js2py.disable_pyimport()
9
app = Flask(__name__)
10
app.secret_key = 'S3cr3tK3yC0d3Tw0'
11
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///users.db'
12
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
13
db = SQLAlchemy(app)
14

15
class User(db.Model):
16
    id = db.Column(db.Integer, primary_key=True)
17
    username = db.Column(db.String(80), unique=True, nullable=False)
18
    password_hash = db.Column(db.String(128), nullable=False)
19

20
class CodeSnippet(db.Model):
21
    id = db.Column(db.Integer, primary_key=True)
22
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
23
    code = db.Column(db.Text, nullable=False)
24

25
@app.route('/')
26
def index():
27
    return render_template('index.html')
28

29
@app.route('/dashboard')
30
def dashboard():
31
    if 'user_id' in session:
32
        user_codes = CodeSnippet.query.filter_by(user_id=session['user_id']).all()
33
        return render_template('dashboard.html', codes=user_codes)
34
    return redirect(url_for('login'))
35

36
@app.route('/register', methods=['GET', 'POST'])
37
def register():
38
    if request.method == 'POST':
39
        username = request.form['username']
40
        password = request.form['password']
41
        password_hash = hashlib.md5(password.encode()).hexdigest()
42
        new_user = User(username=username, password_hash=password_hash)
43
        db.session.add(new_user)
44
        db.session.commit()
45
        return redirect(url_for('login'))
46
    return render_template('register.html')
47

48
@app.route('/login', methods=['GET', 'POST'])
49
def login():
50
    if request.method == 'POST':
51
        username = request.form['username']
52
        password = request.form['password']
53
        password_hash = hashlib.md5(password.encode()).hexdigest()
54
        user = User.query.filter_by(username=username, password_hash=password_hash).first()
55
        if user:
56
            session['user_id'] = user.id
57
            session['username'] = username;
58
            return redirect(url_for('dashboard'))
59
        return "Invalid credentials"
60
    return render_template('login.html')
61

62
@app.route('/logout')
63
def logout():
64
    session.pop('user_id', None)
65
    return redirect(url_for('index'))
66

67
@app.route('/save_code', methods=['POST'])
68
def save_code():
69
    if 'user_id' in session:
70
        code = request.json.get('code')
71
        new_code = CodeSnippet(user_id=session['user_id'], code=code)
72
        db.session.add(new_code)
73
        db.session.commit()
74
        return jsonify({"message": "Code saved successfully"})
75
    return jsonify({"error": "User not logged in"}), 401
76

77
@app.route('/download')
78
def download():
79
    return send_from_directory(directory='/home/app/app/static/', path='app.zip', as_attachment=True)
80

81
@app.route('/delete_code/<int:code_id>', methods=['POST'])
82
def delete_code(code_id):
83
    if 'user_id' in session:
84
        code = CodeSnippet.query.get(code_id)
85
        if code and code.user_id == session['user_id']:
86
            db.session.delete(code)
87
            db.session.commit()
88
            return jsonify({"message": "Code deleted successfully"})
89
        return jsonify({"error": "Code not found"}), 404
90
    return jsonify({"error": "User not logged in"}), 401
91

92
@app.route('/run_code', methods=['POST'])
93
def run_code():
94
    try:
95
        code = request.json.get('code')
96
        result = js2py.eval_js(code)
97
        return jsonify({'result': result})
98
    except Exception as e:
99
        return jsonify({'error': str(e)})
100

101
if __name__ == '__main__':
102
    with app.app_context():
103
        db.create_all()
104
    app.run(host='0.0.0.0', debug=True)

1
js2py.disable_pyimport()
2
app = Flask(__name__)
3
app.secret_key = 'S3cr3tK3yC0d3Tw0'
4
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///users.db'
5
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
6
db = SQLAlchemy(app)

1
marco | 649c9d65a206a75f5abe509fe128bce5
2
app   | a97588c0e2fa3a024876339e27aeb42e

1
a90eb8b312927f4bf9f56831b4af4d82

1
conf_version: 3.0.1
2
audience: public
3
repos:
4
  default:
5
    repo_uri:     __NPBACKUP__wd9051w9Y0p4ZYWmIxMqKHP81/phMlzIOYsL01M9Z7IxNzQzOTEwMDcxLjM5NjQ0Mg8PDw8PDw8PDw8PDw8PD6yVSCEXjl8/9rIqYrh8kIRhlKm4UPcem5kIIFPhSpDU+e+E__NPBACKUP__
6
    repo_group: default_group
7
    backup_opts:
8
      paths:
9
      - /home/app/app/
10
      source_type: folder_list
11
      exclude_files_larger_than: 0.0
12
    repo_opts:
13
      repo_password:       __NPBACKUP__v2zdDN21b0c7TSeUZlwezkPj3n8wlR9Cu1IJSMrSctoxNzQzOTEwMDcxLjM5NjcyNQ8PDw8PDw8PDw8PDw8PD0z8n8DrGuJ3ZVWJwhBl0GHtbaQ8lL3fB0M=__NPBACKUP__
14
      retention_policy: {}
15
      prune_max_unused: 0
16
    prometheus: {}
17
    env: {}
18
    is_protected: false
19
groups:
20
  default_group:
21
    backup_opts:
22
      paths: []
23
      source_type:
24
      stdin_from_command:
25
      stdin_filename:
26
      tags: []
27
      compression: auto
28
      use_fs_snapshot: true
29
      ignore_cloud_files: true
30
      one_file_system: false
31
      priority: low
32
      exclude_caches: true
33
      excludes_case_ignore: false
34
      exclude_files:
35
      - excludes/generic_excluded_extensions
36
      - excludes/generic_excludes
37
      - excludes/windows_excludes
38
      - excludes/linux_excludes
39
      exclude_patterns: []
40
      exclude_files_larger_than:
41
      additional_parameters:
42
      additional_backup_only_parameters:
43
      minimum_backup_size_error: 10 MiB
44
      pre_exec_commands: []
45
      pre_exec_per_command_timeout: 3600
46
      pre_exec_failure_is_fatal: false
47
      post_exec_commands: []
48
      post_exec_per_command_timeout: 3600
49
      post_exec_failure_is_fatal: false
50
      post_exec_execute_even_on_backup_error: true
51
      post_backup_housekeeping_percent_chance: 0
52
      post_backup_housekeeping_interval: 0
53
    repo_opts:
54
      repo_password:
55
      repo_password_command:
56
      minimum_backup_age: 1440
57
      upload_speed: 800 Mib
58
      download_speed: 0 Mib
59
      backend_connections: 0
60
      retention_policy:
61
        last: 3
62
        hourly: 72
63
        daily: 30
64
        weekly: 4
65
        monthly: 12
66
        yearly: 3
67
        tags: []
68
        keep_within: true
69
        group_by_host: true
70
        group_by_tags: true
71
        group_by_paths: false
72
        ntp_server:
73
      prune_max_unused: 0 B
74
      prune_max_repack_size:
75
    prometheus:
76
      backup_job: ${MACHINE_ID}
77
      group: ${MACHINE_GROUP}
78
    env:
79
      env_variables: {}
80
      encrypted_env_variables: {}
81
    is_protected: false
82
identity:
83
  machine_id: ${HOSTNAME}__blw0
84
  machine_group:
85
global_prometheus:
86
  metrics: false
87
  instance: ${MACHINE_ID}
88
  destination:
89
  http_username:
90
  http_password:
91
  additional_labels: {}
92
  no_cert_verify: false
93
global_options:
94
  auto_upgrade: false
95
  auto_upgrade_percent_chance: 5
96
  auto_upgrade_interval: 15
97
  auto_upgrade_server_url:
98
  auto_upgrade_server_username:
99
  auto_upgrade_server_password:
100
  auto_upgrade_host_identity: ${MACHINE_ID}
101
  auto_upgrade_group: ${MACHINE_GROUP}

1
paths:
2
      - /root

1
e7ff41c9ff2b0ae691783c04259b6e2a