Beispiel #1
0
 def test_set_line_field_1(self):
     f1 = make_field(GEOLineField)
     f2 = make_field(GEOLineField)
     f1['coordinates.0'].value = [-1, -2]
     f2['coordinates.0'] = f1['coordinates.0']
     self.assertDictEqual(f2.value, {
         'type': 'LineString',
         'coordinates': [[-1.0, -2.0]]
     })
     self.assertDictEqual(f2.query, {'$set': {
         'type': 'LineString',
         'coordinates': [[-1.0, -2.0]]
     }})
Beispiel #2
0
 def test_set_polygon_field_1(self):
     f1 = make_field(GEOPolygonField)
     f2 = make_field(GEOPolygonField)
     f1['coordinates.0'].value = [[-1, -2], [3, 4]]
     f2['coordinates.0'] = f1['coordinates.0']
     self.assertDictEqual(f2.value, {
         'type': 'Polygon',
         'coordinates': [[[-1.0, -2.0], [3.0, 4.0], [-1.0, -2.0]]]
     })
     self.assertDictEqual(f2.query, {'$set': {
         'type': 'Polygon',
         'coordinates': [[[-1.0, -2.0], [3.0, 4.0], [-1.0, -2.0]]]
     }})
Beispiel #3
0
 def test_set_line_field_1(self):
     f1 = make_field(GEOLineField)
     f2 = make_field(GEOLineField)
     f1['coordinates.0'].value = [-1, -2]
     f2['coordinates.0'] = f1['coordinates.0']
     self.assertDictEqual(f2.value, {
         'type': 'LineString',
         'coordinates': [[-1.0, -2.0]]
     })
     self.assertDictEqual(
         f2.query,
         {'$set': {
             'type': 'LineString',
             'coordinates': [[-1.0, -2.0]]
         }})
Beispiel #4
0
    def test_point_field_2(self):
        f = make_field(GEOPointField([123, 45]))
        self.assertIsInstance(f, GEOPointField)
        self.assertDictEqual(f.value, {
            'type': 'Point',
            'coordinates': [123.0, 45.0]
        })
        self.assertDictEqual(f.query, {})
        f['coordinates'].value = [-1, -2]
        self.assertDictEqual(f.value, {
            'type': 'Point',
            'coordinates': [-1.0, -2.0]
        })
        self.assertEqual(f['coordinates.1'].value, -2.0)
        f['coordinates.1'].value = 3.0
        self.assertDictEqual(f.value, {
            'type': 'Point',
            'coordinates': [-1.0, 3.0]
        })
        with self.assertRaises(IndexError):
            f['coordinates.3'].value = 4.0

        self.assertDictEqual(f.query, {'$set': {
            'type': 'Point',
            'coordinates': [-1.0, 3.0]}
        })
Beispiel #5
0
    def test_point_field_2(self):
        f = make_field(GEOPointField([123, 45]))
        self.assertIsInstance(f, GEOPointField)
        self.assertDictEqual(f.value, {
            'type': 'Point',
            'coordinates': [123.0, 45.0]
        })
        self.assertDictEqual(f.query, {})
        f['coordinates'].value = [-1, -2]
        self.assertDictEqual(f.value, {
            'type': 'Point',
            'coordinates': [-1.0, -2.0]
        })
        self.assertEqual(f['coordinates.1'].value, -2.0)
        f['coordinates.1'].value = 3.0
        self.assertDictEqual(f.value, {
            'type': 'Point',
            'coordinates': [-1.0, 3.0]
        })
        with self.assertRaises(IndexError):
            f['coordinates.3'].value = 4.0

        self.assertDictEqual(
            f.query, {'$set': {
                'type': 'Point',
                'coordinates': [-1.0, 3.0]
            }})
Beispiel #6
0
 def test_set_polygon_field_1(self):
     f1 = make_field(GEOPolygonField)
     f2 = make_field(GEOPolygonField)
     f1['coordinates.0'].value = [[-1, -2], [3, 4]]
     f2['coordinates.0'] = f1['coordinates.0']
     self.assertDictEqual(
         f2.value, {
             'type': 'Polygon',
             'coordinates': [[[-1.0, -2.0], [3.0, 4.0], [-1.0, -2.0]]]
         })
     self.assertDictEqual(
         f2.query, {
             '$set': {
                 'type': 'Polygon',
                 'coordinates': [[[-1.0, -2.0], [3.0, 4.0], [-1.0, -2.0]]]
             }
         })
Beispiel #7
0
    def test_line_field_1(self):
        f = make_field(GEOLineField)
        self.assertIsInstance(f, GEOLineField)
        self.assertDictEqual(f.value, {
            'type': 'LineString',
            'coordinates': []
        })
        self.assertDictEqual(f.query, {})

        f['coordinates.0'].value = [-1, -2]
        self.assertDictEqual(f.value, {
            'type': 'LineString',
            'coordinates': [[-1.0, -2.0]]
        })
        self.assertDictEqual(f.query, {'$set': {
            'type': 'LineString',
            'coordinates': [[-1.0, -2.0]]
        }})

        f['coordinates'].append_value([3, 4])
        self.assertDictEqual(f.value, {
            'type': 'LineString',
            'coordinates': [[-1.0, -2.0], [3.0, 4.0]]
        })
        self.assertDictEqual(f.query, {'$set': {
            'type': 'LineString',
            'coordinates': [[-1.0, -2.0], [3.0, 4.0]]
        }})
        self.assertEqual(f['coordinates.0.1'].value, -2.0)

        f['coordinates.0.1'].value = 3.0
        self.assertDictEqual(f.value, {
            'type': 'LineString',
            'coordinates': [[-1.0, 3.0], [3.0, 4.0]]
        })
        self.assertDictEqual(f.query, {'$set': {
            'type': 'LineString',
            'coordinates': [[-1.0, 3.0], [3.0, 4.0]]
        }})

        f['coordinates.3.1'].value = 4.0
        self.assertDictEqual(f.value, {
            'type': 'LineString',
            'coordinates': [[-1.0, 3.0], [3.0, 4.0], [None, None], [None, 4.0]]
        })
        self.assertDictEqual(f.query, {'$set': {
            'type': 'LineString',
            'coordinates': [[-1.0, 3.0], [3.0, 4.0], [None, None], [None, 4.0]]
        }})

        with self.assertRaises(IndexError):
            f['coordinates.3.4'].value = 5.0
    def test_dict_query_1(self):
        data = {
            'd1': int,
            'd2': [str],
            'd3': (int, str),
            'd4': {
                'dd1': int,
                'dd2': [str],
                'dd3': (int, str)
            },
            'd5': {}
        }
        f = make_field(data)
        self.assertDictEqual(f.query, {})
        f['d1'].value = 123
        print('---1', f.dirty_fields)

        self.assertDictEqual(f.query, {'$set': {'d1': 123}})
        print('---1', f.dirty_fields)
        f['d2.0'].value = 123
        self.assertDictEqual(f.query, {'$set': {
            'd1': 123,
            'd2': ['123']
        }})
        f['d2'][1].value = 'foo'
        self.assertDictEqual(f.query, {'$set': {
            'd1': 123,
            'd2': ['123', 'foo']
        }})
        f['d2'].append_value('bar')
        self.assertDictEqual(f.query, {'$set': {
            'd1': 123,
            'd2': ['123', 'foo', 'bar']
        }})
        f['d2'].set_value(['z', 123])
        self.assertDictEqual(f.query, {'$set': {
            'd1': 123,
            'd2': ['z', '123', 'bar']
        }})
        f['d3.0'].value = 123
        f['d3.1'].value = 123
        print('---3', f.dirty_fields)
        self.assertDictEqual(f.query, {'$set': {
            'd1': 123,
            'd2': ['z', '123', 'bar'],
            'd3': [123, '123']
        }})
        f['d3'].value = [None, 'foo']
        self.assertDictEqual(f.query, {'$set': {
            'd1': 123,
            'd2': ['z', '123', 'bar'],
            'd3': [None, 'foo']
        }})
        f['d4.dd1'].value = 456
        self.assertDictEqual(f.query, {'$set': {
            'd1': 123,
            'd2': ['z', '123', 'bar'],
            'd3': [None, 'foo'],
            'd4.dd1': 456
        }})
        f['d4.dd2'].append_value('bar')
        self.assertDictEqual(f.query, {'$set': {
            'd1': 123,
            'd2': ['z', '123', 'bar'],
            'd3': [None, 'foo'],
            'd4.dd1': 456,
            'd4.dd2': ['bar']
        }})
        f['d4.dd2.2'].value = 'x'
        self.assertDictEqual(f.query, {'$set': {
            'd1': 123,
            'd2': ['z', '123', 'bar'],
            'd3': [None, 'foo'],
            'd4.dd1': 456,
            'd4.dd2': ['bar', None, 'x']
        }})
        f['d4.dd3.1'].value = 456
        self.assertDictEqual(f.query, {'$set': {
            'd1': 123,
            'd2': ['z', '123', 'bar'],
            'd3': [None, 'foo'],
            'd4.dd1': 456,
            'd4.dd2': ['bar', None, 'x'],
            'd4.dd3': [None, '456']
        }})
        print('---4', f.dirty_fields)
        f.dirty_clear()
        self.assertDictEqual(f.query, {})
        f.set_value({
            'd1': 456,
            'd2': ['foo', 'bar'],
            'd3': [123, 'x'],
            'd4': {
                'dd1': 123,
                'dd2': ['a', 'b', 'c'],
                'dd3': [None, None]
            }
        })
        self.assertDictEqual(f.query, {'$set': {
            'd1': 456,
            'd2': ['foo', 'bar', 'bar'],
            'd3': [123, 'x'],
            'd4.dd1': 123,
            'd4.dd2': ['a', 'b', 'c'],
            'd4.dd3': [None, None]
        }})
        f['d5'].value = {'a': 1, 'b': 'foo'}
        print('---5', f.dirty_fields)
        self.assertDictEqual(f.query, {'$set': {
            'd1': 456,
            'd2': ['foo', 'bar', 'bar'],
            'd3': [123, 'x'],
            'd4.dd1': 123,
            'd4.dd2': ['a', 'b', 'c'],
            'd4.dd3': [None, None],
            'd5': {'a': 1, 'b': 'foo'}
        }})

        f['d4.dd3.1'].value = 123
        self.assertDictEqual(f.query, {'$set': {
            'd1': 456,
            'd2': ['foo', 'bar', 'bar'],
            'd3': [123, 'x'],
            'd4.dd1': 123,
            'd4.dd2': ['a', 'b', 'c'],
            'd4.dd3': [None, '123'],
            'd5': {'a': 1, 'b': 'foo'}
        }})
    def test_dict_query_1(self):
        data = {
            'd1': int,
            'd2': [str],
            'd3': (int, str),
            'd4': {
                'dd1': int,
                'dd2': [str],
                'dd3': (int, str)
            },
            'd5': {}
        }
        f = make_field(data)
        self.assertDictEqual(f.query, {})
        f['d1'].value = 123
        print('---1', f.dirty_fields)

        self.assertDictEqual(f.query, {'$set': {'d1': 123}})
        print('---1', f.dirty_fields)
        f['d2.0'].value = 123
        self.assertDictEqual(f.query, {'$set': {'d1': 123, 'd2': ['123']}})
        f['d2'][1].value = 'foo'
        self.assertDictEqual(f.query,
                             {'$set': {
                                 'd1': 123,
                                 'd2': ['123', 'foo']
                             }})
        f['d2'].append_value('bar')
        self.assertDictEqual(
            f.query, {'$set': {
                'd1': 123,
                'd2': ['123', 'foo', 'bar']
            }})
        f['d2'].set_value(['z', 123])
        self.assertDictEqual(f.query,
                             {'$set': {
                                 'd1': 123,
                                 'd2': ['z', '123', 'bar']
                             }})
        f['d3.0'].value = 123
        f['d3.1'].value = 123
        print('---3', f.dirty_fields)
        self.assertDictEqual(f.query, {
            '$set': {
                'd1': 123,
                'd2': ['z', '123', 'bar'],
                'd3': [123, '123']
            }
        })
        f['d3'].value = [None, 'foo']
        self.assertDictEqual(f.query, {
            '$set': {
                'd1': 123,
                'd2': ['z', '123', 'bar'],
                'd3': [None, 'foo']
            }
        })
        f['d4.dd1'].value = 456
        self.assertDictEqual(
            f.query, {
                '$set': {
                    'd1': 123,
                    'd2': ['z', '123', 'bar'],
                    'd3': [None, 'foo'],
                    'd4.dd1': 456
                }
            })
        f['d4.dd2'].append_value('bar')
        self.assertDictEqual(
            f.query, {
                '$set': {
                    'd1': 123,
                    'd2': ['z', '123', 'bar'],
                    'd3': [None, 'foo'],
                    'd4.dd1': 456,
                    'd4.dd2': ['bar']
                }
            })
        f['d4.dd2.2'].value = 'x'
        self.assertDictEqual(
            f.query, {
                '$set': {
                    'd1': 123,
                    'd2': ['z', '123', 'bar'],
                    'd3': [None, 'foo'],
                    'd4.dd1': 456,
                    'd4.dd2': ['bar', None, 'x']
                }
            })
        f['d4.dd3.1'].value = 456
        self.assertDictEqual(
            f.query, {
                '$set': {
                    'd1': 123,
                    'd2': ['z', '123', 'bar'],
                    'd3': [None, 'foo'],
                    'd4.dd1': 456,
                    'd4.dd2': ['bar', None, 'x'],
                    'd4.dd3': [None, '456']
                }
            })
        print('---4', f.dirty_fields)
        f.dirty_clear()
        self.assertDictEqual(f.query, {})
        f.set_value({
            'd1': 456,
            'd2': ['foo', 'bar'],
            'd3': [123, 'x'],
            'd4': {
                'dd1': 123,
                'dd2': ['a', 'b', 'c'],
                'dd3': [None, None]
            }
        })
        self.assertDictEqual(
            f.query, {
                '$set': {
                    'd1': 456,
                    'd2': ['foo', 'bar', 'bar'],
                    'd3': [123, 'x'],
                    'd4.dd1': 123,
                    'd4.dd2': ['a', 'b', 'c'],
                    'd4.dd3': [None, None]
                }
            })
        f['d5'].value = {'a': 1, 'b': 'foo'}
        print('---5', f.dirty_fields)
        self.assertDictEqual(
            f.query, {
                '$set': {
                    'd1': 456,
                    'd2': ['foo', 'bar', 'bar'],
                    'd3': [123, 'x'],
                    'd4.dd1': 123,
                    'd4.dd2': ['a', 'b', 'c'],
                    'd4.dd3': [None, None],
                    'd5': {
                        'a': 1,
                        'b': 'foo'
                    }
                }
            })

        f['d4.dd3.1'].value = 123
        self.assertDictEqual(
            f.query, {
                '$set': {
                    'd1': 456,
                    'd2': ['foo', 'bar', 'bar'],
                    'd3': [123, 'x'],
                    'd4.dd1': 123,
                    'd4.dd2': ['a', 'b', 'c'],
                    'd4.dd3': [None, '123'],
                    'd5': {
                        'a': 1,
                        'b': 'foo'
                    }
                }
            })
Beispiel #10
0
 def test_type_1(self):
     f = make_field(GEOPointField)
     self.assertEqual(f['type'].value, 'Point')
     f['type'].value = 'foo'
     self.assertEqual(f['type'].value, 'Point')
Beispiel #11
0
    def test_polygon_field_1(self):
        f = make_field(GEOPolygonField)
        self.assertIsInstance(f, GEOPolygonField)
        self.assertDictEqual(f.value, {
            'type': 'Polygon',
            'coordinates': []
        })
        self.assertDictEqual(f.query, {})

        f['coordinates.0.0'].value = [-1, -2]
        self.assertDictEqual(f.value, {
            'type': 'Polygon',
            'coordinates': [
                [[-1.0, -2.0]]
            ]
        })
        self.assertDictEqual(f.query, {'$set': {
            'type': 'Polygon',
            'coordinates': [
                [[-1.0, -2.0]]
            ]
        }})

        f['coordinates.0'].append_value([3, 4])
        self.assertDictEqual(f.value, {
            'type': 'Polygon',
            'coordinates': [
                [[-1.0, -2.0], [3.0, 4.0], [-1.0, -2.0]]
            ]
        })
        self.assertDictEqual(f.query, {'$set': {
            'type': 'Polygon',
            'coordinates': [
                [[-1.0, -2.0], [3.0, 4.0], [-1.0, -2.0]]
            ]
        }})
        self.assertEqual(f['coordinates.0.0.1'].value, -2.0)

        f['coordinates.0.0.1'].value = 3.0

        self.assertDictEqual(f.value, {
            'type': 'Polygon',
            'coordinates': [
                [[-1.0, 3.0], [3.0, 4.0], [-1.0, 3.0]]
            ]
        })
        self.assertDictEqual(f.query, {'$set': {
            'type': 'Polygon',
            'coordinates': [
                [[-1.0, 3.0], [3.0, 4.0], [-1.0, 3.0]]
            ]
        }})

        f['coordinates.0.3.1'].value = 4.0

        self.assertDictEqual(f.value, {
            'type': 'Polygon',
            'coordinates': [
                [[-1.0, 3.0], [3.0, 4.0], [None, None], [None, 4.0], [-1.0, 3.0]]
            ]
        })
        self.assertDictEqual(f.query, {'$set': {
            'type': 'Polygon',
            'coordinates': [
                [[-1.0, 3.0], [3.0, 4.0], [None, None], [None, 4.0], [-1.0, 3.0]]
            ]
        }})

        with self.assertRaises(IndexError):
            f['coordinates.0.3.4'].value = 5.0

        f['coordinates.0'].append_value([5, 6.0])
        self.assertDictEqual(f.value, {
            'type': 'Polygon',
            'coordinates': [
                [[-1.0, 3.0], [3.0, 4.0], [None, None], [None, 4.0], [5.0, 6.0], [-1.0, 3.0]]
            ]
        })
        self.assertDictEqual(f.query, {'$set': {
            'type': 'Polygon',
            'coordinates': [
                [[-1.0, 3.0], [3.0, 4.0], [None, None], [None, 4.0], [5.0, 6.0], [-1.0, 3.0]]
            ]
        }})

        f['coordinates.1'].append_value([7, 8.0])
        f['coordinates.1.1'].value = [9, 10.0]
        self.assertDictEqual(f.value, {
            'type': 'Polygon',
            'coordinates': [
                [[-1.0, 3.0], [3.0, 4.0], [None, None], [None, 4.0], [5.0, 6.0], [-1.0, 3.0]],
                [[7.0, 8.0], [9.0, 10.0], [7.0, 8.0]]
            ]
        })
        self.assertDictEqual(f.query, {'$set': {
            'type': 'Polygon',
            'coordinates': [
                [[-1.0, 3.0], [3.0, 4.0], [None, None], [None, 4.0], [5.0, 6.0], [-1.0, 3.0]],
                [[7.0, 8.0], [9.0, 10.0], [7.0, 8.0]]
            ]
        }})
Beispiel #12
0
    def test_line_field_1(self):
        f = make_field(GEOLineField)
        self.assertIsInstance(f, GEOLineField)
        self.assertDictEqual(f.value, {
            'type': 'LineString',
            'coordinates': []
        })
        self.assertDictEqual(f.query, {})

        f['coordinates.0'].value = [-1, -2]
        self.assertDictEqual(f.value, {
            'type': 'LineString',
            'coordinates': [[-1.0, -2.0]]
        })
        self.assertDictEqual(
            f.query,
            {'$set': {
                'type': 'LineString',
                'coordinates': [[-1.0, -2.0]]
            }})

        f['coordinates'].append_value([3, 4])
        self.assertDictEqual(f.value, {
            'type': 'LineString',
            'coordinates': [[-1.0, -2.0], [3.0, 4.0]]
        })
        self.assertDictEqual(
            f.query, {
                '$set': {
                    'type': 'LineString',
                    'coordinates': [[-1.0, -2.0], [3.0, 4.0]]
                }
            })
        self.assertEqual(f['coordinates.0.1'].value, -2.0)

        f['coordinates.0.1'].value = 3.0
        self.assertDictEqual(f.value, {
            'type': 'LineString',
            'coordinates': [[-1.0, 3.0], [3.0, 4.0]]
        })
        self.assertDictEqual(
            f.query, {
                '$set': {
                    'type': 'LineString',
                    'coordinates': [[-1.0, 3.0], [3.0, 4.0]]
                }
            })

        f['coordinates.3.1'].value = 4.0
        self.assertDictEqual(
            f.value, {
                'type': 'LineString',
                'coordinates': [[-1.0, 3.0], [3.0, 4.0], [None, None],
                                [None, 4.0]]
            })
        self.assertDictEqual(
            f.query, {
                '$set': {
                    'type':
                    'LineString',
                    'coordinates': [[-1.0, 3.0], [3.0, 4.0], [None, None],
                                    [None, 4.0]]
                }
            })

        with self.assertRaises(IndexError):
            f['coordinates.3.4'].value = 5.0
Beispiel #13
0
 def test_type_1(self):
     f = make_field(GEOPointField)
     self.assertEqual(f['type'].value, 'Point')
     f['type'].value = 'foo'
     self.assertEqual(f['type'].value, 'Point')
Beispiel #14
0
    def test_polygon_field_1(self):
        f = make_field(GEOPolygonField)
        self.assertIsInstance(f, GEOPolygonField)
        self.assertDictEqual(f.value, {'type': 'Polygon', 'coordinates': []})
        self.assertDictEqual(f.query, {})

        f['coordinates.0.0'].value = [-1, -2]
        self.assertDictEqual(f.value, {
            'type': 'Polygon',
            'coordinates': [[[-1.0, -2.0]]]
        })
        self.assertDictEqual(
            f.query,
            {'$set': {
                'type': 'Polygon',
                'coordinates': [[[-1.0, -2.0]]]
            }})

        f['coordinates.0'].append_value([3, 4])
        self.assertDictEqual(
            f.value, {
                'type': 'Polygon',
                'coordinates': [[[-1.0, -2.0], [3.0, 4.0], [-1.0, -2.0]]]
            })
        self.assertDictEqual(
            f.query, {
                '$set': {
                    'type': 'Polygon',
                    'coordinates': [[[-1.0, -2.0], [3.0, 4.0], [-1.0, -2.0]]]
                }
            })
        self.assertEqual(f['coordinates.0.0.1'].value, -2.0)

        f['coordinates.0.0.1'].value = 3.0

        self.assertDictEqual(
            f.value, {
                'type': 'Polygon',
                'coordinates': [[[-1.0, 3.0], [3.0, 4.0], [-1.0, 3.0]]]
            })
        self.assertDictEqual(
            f.query, {
                '$set': {
                    'type': 'Polygon',
                    'coordinates': [[[-1.0, 3.0], [3.0, 4.0], [-1.0, 3.0]]]
                }
            })

        f['coordinates.0.3.1'].value = 4.0

        self.assertDictEqual(
            f.value, {
                'type':
                'Polygon',
                'coordinates': [[[-1.0, 3.0], [3.0, 4.0], [None, None],
                                 [None, 4.0], [-1.0, 3.0]]]
            })
        self.assertDictEqual(
            f.query, {
                '$set': {
                    'type':
                    'Polygon',
                    'coordinates': [[[-1.0, 3.0], [3.0, 4.0], [None, None],
                                     [None, 4.0], [-1.0, 3.0]]]
                }
            })

        with self.assertRaises(IndexError):
            f['coordinates.0.3.4'].value = 5.0

        f['coordinates.0'].append_value([5, 6.0])
        self.assertDictEqual(
            f.value, {
                'type':
                'Polygon',
                'coordinates': [[[-1.0, 3.0], [3.0, 4.0], [None, None],
                                 [None, 4.0], [5.0, 6.0], [-1.0, 3.0]]]
            })
        self.assertDictEqual(
            f.query, {
                '$set': {
                    'type':
                    'Polygon',
                    'coordinates': [[[-1.0, 3.0], [3.0, 4.0], [None, None],
                                     [None, 4.0], [5.0, 6.0], [-1.0, 3.0]]]
                }
            })

        f['coordinates.1'].append_value([7, 8.0])
        f['coordinates.1.1'].value = [9, 10.0]
        self.assertDictEqual(
            f.value, {
                'type':
                'Polygon',
                'coordinates': [[[-1.0, 3.0], [3.0, 4.0], [None, None],
                                 [None, 4.0], [5.0, 6.0], [-1.0, 3.0]],
                                [[7.0, 8.0], [9.0, 10.0], [7.0, 8.0]]]
            })
        self.assertDictEqual(
            f.query, {
                '$set': {
                    'type':
                    'Polygon',
                    'coordinates': [[[-1.0, 3.0], [3.0, 4.0], [None, None],
                                     [None, 4.0], [5.0, 6.0], [-1.0, 3.0]],
                                    [[7.0, 8.0], [9.0, 10.0], [7.0, 8.0]]]
                }
            })