modular-odm-admin/main.py at master · cos-archives/modular-odm-admin · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
#TODO backref popovers

from flask import Flask, request, jsonify, render_template
import models
from modularodm.fields import Field
from collections import OrderedDict
import json

app = Flask(__name__)

from mako.lookup import TemplateLookup

makolookup = TemplateLookup(directories=['templates'])

def render(filename, **kwargs):
    t = makolookup.get_template(filename).render(**kwargs)
    return t

def get_schema_keys(schema_name):
    schema = models.StoredObject._collections[schema_name]
    schema_keys = {k:v.__class__.__name__ for k,v in schema.__dict__.iteritems() if isinstance(v, Field)}
    return schema_keys

@app.route('/', methods=['GET', 'POST'])
def index():
    schemas = models.StoredObject._collections
    return render(
        filename="index.mako",
        schemas=schemas)

@app.route('/<schema_name>/')
def schema_display(schema_name):
    schema_obj = models.StoredObject._collections[schema_name]
    primary_name = schema_obj._primary_name
    schema_info = json.dumps(get_schema_keys(schema_name))
    schema_entries = schema_obj.find_all()
    entry_data = []
    for i in list(schema_entries):
        storage = i.to_storage()
        ordered = OrderedDict()
        ordered[primary_name] = storage[primary_name]
        for key, value in storage.iteritems():
            if key is not primary_name and key is not "_backrefs":
                ordered[key]=value
        ordered[""] = "<a href='/{title}/{object}/edit'>edit</a>".format(title=schema_name, object=storage[primary_name])
        entry_data.append(ordered)
    return render(
        filename="schema_obj.mako",
        title=schema_name,
        schema_info=schema_info,
        schema_entries=entry_data
    )

@app.route('/<schema_name>/<sid>/')
def view_as_json(schema_name, sid):
    schema_class = models.StoredObject._collections[schema_name]
    schema_obj = schema_class.load(sid)
    json_data = schema_obj.to_storage()
    return jsonify(json_data)

@app.route('/<schema_name>/<sid>/edit', methods=['GET', 'POST'])
def edit(schema_name, sid):
    schema_class = models.StoredObject._collections[schema_name]
    schema_obj = schema_class.load(sid)
    data_dict = schema_obj.to_storage()
    message=""

    if request.method == 'POST':
        for key in data_dict.keys():
            if key in json.loads(request.form['json_data']) and key is not "_backrefs":
                incoming_data = json.loads(request.form['json_data'])
                field_type = type(schema_obj._fields[key]).__name__
                if field_type is 'BooleanField':
                    new_value = incoming_data[key]
                    if new_value == 'True':
                        new_value = True
                    else:
                        new_value = False
                elif field_type is 'IntegerField':
                    new_value = int(incoming_data[key])
                elif field_type is 'FloatField':
                    new_value = float(incoming_data[key])
                elif field_type is 'ListField':
                    base_field_type = type(schema_obj._fields[key]._field_instance).__name__
                    if base_field_type is 'BooleanField':
                        new_value = str(incoming_data[key]).split(',')
                        for i in new_value:
                            if i == 'True':
                                i = True
                            else:
                                i = False
                    elif base_field_type is 'IntegerField':
                        new_value = int(str(incoming_data[key]).split(','))
                    elif base_field_type is 'FloatField':
                        new_value = float(str(incoming_data[key]).split(','))
                    # elif base_field_type is 'DictionaryField':
                    #     (incoming_data[key])
                    # elif base_field_type is 'DateTimeField':
                    #     (incoming_data[key])
                    elif base_field_type is 'StringField':
                        new_value = str(incoming_data[key]).split(',')

                # elif field_type is 'DictionaryField':
                #     (incoming_data[key])
                # elif field_type is 'DateTimeField':
                #     (incoming_data[key])
                elif field_type is 'StringField':
                    new_value = str(incoming_data[key])
                else:
                    foreign_class = schema_obj._fields[key].base_class
                    old_value = getattr(schema_obj, key)
                    try:
                        foreign_obj = foreign_class.load(incoming_data[key])
                    except KeyError:
                        print "No object with that name"

                    if schema_obj._fields[key]._list:
                        foreign_obj = [foreign_obj]

                    if old_value != foreign_obj:
                        new_value = foreign_obj

                setattr(schema_obj, key, new_value)

        schema_obj.save()
        data_dict = schema_obj.to_storage()
        message="Edit was successful!"

    for key, value in schema_obj._fields.iteritems():
        if value.__class__.__name__ == 'ForeignField':
            foreign_key_dict = {}
            # foreign_obj = models.StoredObject._collections[key]
            foreign_obj = getattr(schema_obj, key)
            foreign_key_dict['foreign'] = True
            foreign_key_dict['schema_name'] = foreign_obj._name
            foreign_key_dict['foreign_obj'] = json.dumps(foreign_obj.to_storage())
            foreign_key_dict['primary_value'] = foreign_obj.to_storage()[foreign_obj._primary_name]
            data_dict[key] = foreign_key_dict
        if value.__class__.__name__ == 'ListField':
            if value._field_instance.__class__.__name__ == 'ForeignField':
                new_data = []
                for foreign_obj in getattr(schema_obj, key):
                    foreign_key_dict={}
                    foreign_key_dict['foreign'] = True
                    foreign_key_dict['schema_name'] = foreign_obj._name
                    foreign_key_dict['foreign_obj'] = json.dumps(foreign_obj.to_storage())
                    foreign_key_dict['primary_value'] = foreign_obj.to_storage()[foreign_obj._primary_name]
                    new_data.append(foreign_key_dict)
                data_dict[key]=new_data

                # if type(value._field_instance).__name__ == 'ForeignField'
        #     print type(value._field_instance).__name__

    # for key, value in schema_obj._fields.iteritems():
    #     if value.__class__.__name__ == 'ForeignField' or value.__class__.__name__ == 'ListField':
    #         data_dict[key]={'foreign': True, 'foreign_obj': data_dict[key]}

    return render(
        filename="edit.mako",
        schema_name=schema_name,
        schema_obj_data=data_dict,
        json_data=json.dumps(data_dict),
        schema_primary_name=schema_class._primary_name,
        message=message
    )

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