| 1 | import json |
|---|
| 2 | from base64 import b64encode |
|---|
| 3 | from datetime import date, time, datetime |
|---|
| 4 | from .._compat import PY2, integer_types, to_unicode, to_bytes, basestring |
|---|
| 5 | from ..adapters.base import SQLAdapter, NoSQLAdapter |
|---|
| 6 | from ..helpers.classes import Reference, SQLCustomType |
|---|
| 7 | from ..helpers.methods import bar_encode |
|---|
| 8 | from ..helpers.serializers import serializers |
|---|
| 9 | from ..objects import Row, Expression, Field |
|---|
| 10 | from . import Representer, representers, for_type, before_type, for_instance, pre |
|---|
| 11 | |
|---|
| 12 | long = integer_types[-1] |
|---|
| 13 | NoneType = type(None) |
|---|
| 14 | |
|---|
| 15 | |
|---|
| 16 | class BaseRepresenter(Representer): |
|---|
| 17 | @for_type("boolean", adapt=False) |
|---|
| 18 | def _boolean(self, value): |
|---|
| 19 | if value and not str(value)[:1].upper() in "0F": |
|---|
| 20 | return self.adapter.smart_adapt(self.dialect.true) |
|---|
| 21 | return self.adapter.smart_adapt(self.dialect.false) |
|---|
| 22 | |
|---|
| 23 | @for_type("id", adapt=False) |
|---|
| 24 | def _id(self, value): |
|---|
| 25 | return str(long(value)) |
|---|
| 26 | |
|---|
| 27 | @for_type("integer", adapt=False) |
|---|
| 28 | def _integer(self, value): |
|---|
| 29 | return str(long(value)) |
|---|
| 30 | |
|---|
| 31 | @for_type("decimal", adapt=False) |
|---|
| 32 | def _decimal(self, value): |
|---|
| 33 | return str(value) |
|---|
| 34 | |
|---|
| 35 | @for_type("double", adapt=False) |
|---|
| 36 | def _double(self, value): |
|---|
| 37 | return repr(float(value)) |
|---|
| 38 | |
|---|
| 39 | @for_type("date", encode=True) |
|---|
| 40 | def _date(self, value): |
|---|
| 41 | if isinstance(value, (date, datetime)): |
|---|
| 42 | return value.isoformat()[:10] |
|---|
| 43 | return str(value) |
|---|
| 44 | |
|---|
| 45 | @for_type("time", encode=True) |
|---|
| 46 | def _time(self, value): |
|---|
| 47 | if isinstance(value, time): |
|---|
| 48 | return value.isoformat()[:10] |
|---|
| 49 | return str(value) |
|---|
| 50 | |
|---|
| 51 | @for_type("datetime", encode=True) |
|---|
| 52 | def _datetime(self, value): |
|---|
| 53 | if isinstance(value, datetime): |
|---|
| 54 | value = value.isoformat(self.dialect.dt_sep)[:19] |
|---|
| 55 | elif isinstance(value, date): |
|---|
| 56 | value = value.isoformat()[:10] + self.dialect.dt_sep + "00:00:00" |
|---|
| 57 | else: |
|---|
| 58 | value = str(value) |
|---|
| 59 | return value |
|---|
| 60 | |
|---|
| 61 | def _ensure_list(self, value): |
|---|
| 62 | if not value: |
|---|
| 63 | value = [] |
|---|
| 64 | elif not isinstance(value, (list, tuple)): |
|---|
| 65 | value = [value] |
|---|
| 66 | return value |
|---|
| 67 | |
|---|
| 68 | def _listify_elements(self, elements): |
|---|
| 69 | return bar_encode(elements) |
|---|
| 70 | |
|---|
| 71 | @for_type("list:integer") |
|---|
| 72 | def _list_integer(self, value): |
|---|
| 73 | values = self._ensure_list(value) |
|---|
| 74 | values = [int(val) for val in values if val != ""] |
|---|
| 75 | return self._listify_elements(values) |
|---|
| 76 | |
|---|
| 77 | @for_type("list:string") |
|---|
| 78 | def _list_string(self, value): |
|---|
| 79 | value = self._ensure_list(value) |
|---|
| 80 | if PY2: |
|---|
| 81 | try: |
|---|
| 82 | value = map(str, value) |
|---|
| 83 | except: |
|---|
| 84 | value = map(lambda x: unicode(x).encode(self.adapter.db_codec), value) |
|---|
| 85 | else: |
|---|
| 86 | value = list(map(str, value)) |
|---|
| 87 | return self._listify_elements(value) |
|---|
| 88 | |
|---|
| 89 | @for_type("list:reference", adapt=False) |
|---|
| 90 | def _list_reference(self, value): |
|---|
| 91 | return self.registered_t["list:integer"](value, "list:reference") |
|---|
| 92 | |
|---|
| 93 | |
|---|
| 94 | class JSONRepresenter(Representer): |
|---|
| 95 | @for_type("json", encode=True) |
|---|
| 96 | def _json(self, value): |
|---|
| 97 | return serializers.json(value) |
|---|
| 98 | |
|---|
| 99 | |
|---|
| 100 | @representers.register_for(SQLAdapter) |
|---|
| 101 | class SQLRepresenter(BaseRepresenter): |
|---|
| 102 | def _custom_type(self, value, field_type): |
|---|
| 103 | value = field_type.encoder(value) |
|---|
| 104 | if value and field_type.type in ("string", "text", "json"): |
|---|
| 105 | return self.adapter.adapt(value) |
|---|
| 106 | return value or "NULL" |
|---|
| 107 | |
|---|
| 108 | @pre() |
|---|
| 109 | def _before_all(self, obj, field_type): |
|---|
| 110 | if isinstance(field_type, SQLCustomType): |
|---|
| 111 | return self._custom_type(obj, field_type) |
|---|
| 112 | if obj == "" and not field_type[:2] in ("st", "te", "js", "pa", "up"): |
|---|
| 113 | return "NULL" |
|---|
| 114 | r = self.exceptions(obj, field_type) |
|---|
| 115 | return r |
|---|
| 116 | |
|---|
| 117 | def exceptions(self, obj, field_type): |
|---|
| 118 | return None |
|---|
| 119 | |
|---|
| 120 | @for_instance(NoneType) |
|---|
| 121 | def _none(self, value, field_type): |
|---|
| 122 | return "NULL" |
|---|
| 123 | |
|---|
| 124 | @for_instance(Expression) |
|---|
| 125 | def _expression(self, value, field_type): |
|---|
| 126 | return str(value) |
|---|
| 127 | |
|---|
| 128 | @for_instance(Field) |
|---|
| 129 | def _fieldexpr(self, value, field_type): |
|---|
| 130 | return str(value) |
|---|
| 131 | |
|---|
| 132 | @before_type("reference") |
|---|
| 133 | def reference_extras(self, field_type): |
|---|
| 134 | return {"referenced": field_type[9:].strip()} |
|---|
| 135 | |
|---|
| 136 | @for_type("reference", adapt=False) |
|---|
| 137 | def _reference(self, value, referenced): |
|---|
| 138 | if referenced in self.adapter.db.tables: |
|---|
| 139 | return str(long(value)) |
|---|
| 140 | p = referenced.partition(".") |
|---|
| 141 | if p[2] != "": |
|---|
| 142 | try: |
|---|
| 143 | ftype = self.adapter.db[p[0]][p[2]].type |
|---|
| 144 | return self.adapter.represent(value, ftype) |
|---|
| 145 | except (ValueError, KeyError): |
|---|
| 146 | return repr(value) |
|---|
| 147 | elif isinstance(value, (Row, Reference)): |
|---|
| 148 | return str(value["id"]) |
|---|
| 149 | return str(long(value)) |
|---|
| 150 | |
|---|
| 151 | @for_type("blob", encode=True) |
|---|
| 152 | def _blob(self, value): |
|---|
| 153 | return b64encode(to_bytes(value)) |
|---|
| 154 | |
|---|
| 155 | |
|---|
| 156 | @representers.register_for(NoSQLAdapter) |
|---|
| 157 | class NoSQLRepresenter(BaseRepresenter): |
|---|
| 158 | def adapt(self, value): |
|---|
| 159 | return value |
|---|
| 160 | |
|---|
| 161 | @pre(is_breaking=True) |
|---|
| 162 | def _before_all(self, obj, field_type): |
|---|
| 163 | if isinstance(field_type, SQLCustomType): |
|---|
| 164 | return True, field_type.encoder(obj) |
|---|
| 165 | return False, obj |
|---|
| 166 | |
|---|
| 167 | @pre(is_breaking=True) |
|---|
| 168 | def _nullify_empty_string(self, obj, field_type): |
|---|
| 169 | if obj == "" and not ( |
|---|
| 170 | isinstance(field_type, str) and field_type[:2] in ("st", "te", "pa", "up") |
|---|
| 171 | ): |
|---|
| 172 | return True, None |
|---|
| 173 | return False, obj |
|---|
| 174 | |
|---|
| 175 | @for_instance(NoneType) |
|---|
| 176 | def _none(self, value, field_type): |
|---|
| 177 | return None |
|---|
| 178 | |
|---|
| 179 | @for_instance(list, repr_type=True) |
|---|
| 180 | def _repr_list(self, value, field_type): |
|---|
| 181 | if isinstance(field_type, str) and not field_type.startswith("list:"): |
|---|
| 182 | return [self.adapter.represent(v, field_type) for v in value] |
|---|
| 183 | return value |
|---|
| 184 | |
|---|
| 185 | @for_type("id") |
|---|
| 186 | def _id(self, value): |
|---|
| 187 | return long(value) |
|---|
| 188 | |
|---|
| 189 | @for_type("integer") |
|---|
| 190 | def _integer(self, value): |
|---|
| 191 | return long(value) |
|---|
| 192 | |
|---|
| 193 | @for_type("bigint") |
|---|
| 194 | def _bigint(self, value): |
|---|
| 195 | return long(value) |
|---|
| 196 | |
|---|
| 197 | @for_type("double") |
|---|
| 198 | def _double(self, value): |
|---|
| 199 | return float(value) |
|---|
| 200 | |
|---|
| 201 | @for_type("reference") |
|---|
| 202 | def _reference(self, value): |
|---|
| 203 | if isinstance(value, (Row, Reference)): |
|---|
| 204 | value = value["id"] |
|---|
| 205 | return long(value) |
|---|
| 206 | |
|---|
| 207 | @for_type("boolean") |
|---|
| 208 | def _boolean(self, value): |
|---|
| 209 | if not isinstance(value, bool): |
|---|
| 210 | if value and not str(value)[:1].upper() in "0F": |
|---|
| 211 | return True |
|---|
| 212 | return False |
|---|
| 213 | return value |
|---|
| 214 | |
|---|
| 215 | @for_type("string") |
|---|
| 216 | def _string(self, value): |
|---|
| 217 | return to_unicode(value) |
|---|
| 218 | |
|---|
| 219 | @for_type("password") |
|---|
| 220 | def _password(self, value): |
|---|
| 221 | return to_unicode(value) |
|---|
| 222 | |
|---|
| 223 | @for_type("text") |
|---|
| 224 | def _text(self, value): |
|---|
| 225 | return to_unicode(value) |
|---|
| 226 | |
|---|
| 227 | @for_type("blob") |
|---|
| 228 | def _blob(self, value): |
|---|
| 229 | return value |
|---|
| 230 | |
|---|
| 231 | @for_type("json") |
|---|
| 232 | def _json(self, value): |
|---|
| 233 | if isinstance(value, basestring): |
|---|
| 234 | value = to_unicode(value) |
|---|
| 235 | value = json.loads(value) |
|---|
| 236 | return value |
|---|
| 237 | |
|---|
| 238 | def _represent_list(self, value): |
|---|
| 239 | items = self._ensure_list(value) |
|---|
| 240 | return [item for item in items if item is not None] |
|---|
| 241 | |
|---|
| 242 | @for_type("date") |
|---|
| 243 | def _date(self, value): |
|---|
| 244 | if not isinstance(value, date): |
|---|
| 245 | (y, m, d) = map(int, str(value).strip().split("-")) |
|---|
| 246 | value = date(y, m, d) |
|---|
| 247 | elif isinstance(value, datetime): |
|---|
| 248 | (y, m, d) = (value.year, value.month, value.day) |
|---|
| 249 | value = date(y, m, d) |
|---|
| 250 | return value |
|---|
| 251 | |
|---|
| 252 | @for_type("time") |
|---|
| 253 | def _time(self, value): |
|---|
| 254 | if not isinstance(value, time): |
|---|
| 255 | time_items = list(map(int, str(value).strip().split(":")[:3])) |
|---|
| 256 | if len(time_items) == 3: |
|---|
| 257 | (h, mi, s) = time_items |
|---|
| 258 | else: |
|---|
| 259 | (h, mi, s) = time_items + [0] |
|---|
| 260 | value = time(h, mi, s) |
|---|
| 261 | return value |
|---|
| 262 | |
|---|
| 263 | @for_type("datetime") |
|---|
| 264 | def _datetime(self, value): |
|---|
| 265 | if not isinstance(value, datetime): |
|---|
| 266 | svalue = str(value)[:19] |
|---|
| 267 | (y, m, d) = map(int, svalue[:10].strip().split("-")) |
|---|
| 268 | tp = svalue[11:].strip().split(":")[:3] |
|---|
| 269 | while len(tp) < 3: |
|---|
| 270 | tp.append(0) |
|---|
| 271 | (h, mi, s) = map(int, tp) |
|---|
| 272 | value = datetime(y, m, d, h, mi, s) |
|---|
| 273 | return value |
|---|
| 274 | |
|---|
| 275 | @for_type("list:integer") |
|---|
| 276 | def _list_integer(self, value): |
|---|
| 277 | values = self._represent_list(value) |
|---|
| 278 | return list(map(int, values)) |
|---|
| 279 | |
|---|
| 280 | @for_type("list:string") |
|---|
| 281 | def _list_string(self, value): |
|---|
| 282 | values = self._represent_list(value) |
|---|
| 283 | return list(map(to_unicode, values)) |
|---|
| 284 | |
|---|
| 285 | @for_type("list:reference") |
|---|
| 286 | def _list_reference(self, value): |
|---|
| 287 | values = self._represent_list(value) |
|---|
| 288 | return list(map(long, values)) |
|---|
