De estar presentes las claves necesarias, genera el diccionario
    "contactPoint" de un dataset.
329893
def _make_contact_point(dataset):
    """"""
    keys = [k for k in ["contactPoint_fn", "contactPoint_hasEmail"]
            if k in dataset]
    if keys:
        dataset["contactPoint"] = {
            key.replace("contactPoint_", ""): dataset.pop(key) for key in keys
        }
    return dataset
914302
public function actionIndex()
    {
        $searchModel = new ContactSearch();
        $dataProvider = $searchModel->search(request()->queryParams);
        $dataProvider->sort->defaultOrder = ['id' => SORT_DESC];

        return $this->render('index', [
            'searchModel' => $searchModel,
            'dataProvider' => $dataProvider,
        ]);
    }
129534
def ConsultarTipoActividad(self, sep="||"):
        ""
        ret = self.client.tipoActividadConsultar(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['tipoActividadReturn']
        self.__analizar_errores(ret)
        array = ret.get('tiposActividad', [])
        return [("%s %%s %s %%s %s" % (sep, sep, sep)) %
                    (it['codigoDescripcion']['codigo'], 
                     it['codigoDescripcion']['descripcion']) 
               for it in array]
598316
function createContact() {
    $cnt = count( $this->contact );
    if( 0 >= $cnt )
      return;
    $output = null;
    foreach( $this->contact as $contact ) {
      $attributes = $this->_createParams( $contact['params'], array( 'ALTREP', 'LANGUAGE' ));
      $content    = $this->_strrep( $contact['value'] );
      $output    .= $this->_createElement( 'CONTACT', $attributes, $content );
    }
    return $output;
  }
531594
function(apiKey, contactList, fromAddress,
        toAddress, ccAddresses, bccAddresses, contentType, subject, htmlBody,
        textBody, _templateId) {}
758562
def GenerarRemito(self, id_req, archivo="qr.png"):
        ""
        if not self.remito['arrayContingencias']:
            del self.remito['arrayContingencias']
        response = self.client.generarRemito(
                                authRequest={'token': self.Token, 'sign': self.Sign, 'cuitRepresentada': self.Cuit},
                                idReq=id_req, remito=self.remito) 
        ret = response.get("generarRemitoReturn")
        if ret:
            self.__analizar_errores(ret)
            self.__analizar_observaciones(ret)
            self.__analizar_evento(ret)
            self.AnalizarRemito(ret, archivo)
        return bool(self.CodRemito)
149354
def ObtenerTablaParametros(self, tipo_recurso, sep="||"):
        ""        
        if not self.client:
            self.Conectar()
        self.response = self.client("parametros", "v1", tipo_recurso)
        result = json.loads(self.response)
        ret = {}
        if result['success']:
            data = result['data']
            # armo un diccionario con los datos devueltos:
            key = [k for k in data[0].keys() if k.startswith("id")][0]
            val = [k for k in data[0].keys() if k.startswith("desc")][0]
            for it in data:
                ret[it[key]] = it[val]
            self.data = data
        else:
            error = result['error']
            self.Excepcion = error['mensaje']
        if sep:
            return ["%s%%s%s%%s%s" % (sep, sep, sep) % it for it in sorted(ret.items())]
        else:
            return ret
142431
def __analizar_evento(self, ret):
        ""
        evt = ret.get('evento')
        if evt:
            self.Eventos = [evt]
            self.Evento = "%(codigo)s: %(descripcion)s" % evt
554122
def ConsultarGastos(self, sep="||"):
        ""
        ret = self.client.consultarGastos(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['respuesta']
        self.__analizar_errores(ret)
        array = ret.get('gasto', [])
        if sep is None:
            return dict([(it['codigo'], it['descripcion']) for it in array])
        else:
            return [("%s %%s %s %%s %s" % (sep, sep, sep)) %
                    (it['codigo'], it['descripcion']) for it in array]
1322982
public function listContacts($optParams = array()) {
      $params = array();
      $params = array_merge($params, $optParams);
      $data = $this->__call('list', array($params));
      if ($this->useObjects()) {
        return new ContactsListResponse($data);
      } else {
        return $data;
      }
    }
1185869
def ConsultarCategorias(self, sep="||"):
        ""
        ret = self.client.consultarCategorias(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['respuesta']
        self.__analizar_errores(ret)
        array = ret.get('categoria', []) + ret.get('categoriaPorcina', [])
        if sep is None:
            return dict([(it['codigo'], it['descripcion']) for it in array])
        else:
            return [("%s %%s %s %%s %s" % (sep, sep, sep)) %
                    (it['codigo'], it['descripcion']) for it in array]
1335273
public function getContactEvents($contactId, $search = '', $start = 0, $limit = 0, $orderBy = '', $orderByDir = 'ASC')
    {
        $parameters = array(
            'search'        => $search,
            'start'         => $start,
            'limit'         => $limit,
            'orderBy'       => $orderBy,
            'orderByDir'    => $orderByDir,
        );

        $parameters = array_filter($parameters);

        return $this->makeRequest($this->endpoint.'/contact/'.$contactId, $parameters);
    }
832547
def output_contact_info(gandi, data, output_keys, justify=10):
    """"""
    for key in output_keys:
        if data[key]:
            output_line(gandi, key, data[key]['handle'], justify)
494654
def iter_custom_errors(catalog):
    

    try:
        # chequea que no se repiten los ids de la taxonomía específica
        if "themeTaxonomy" in catalog:
            theme_ids = [theme["id"] for theme in catalog["themeTaxonomy"]]
            dups = _find_dups(theme_ids)
            if len(dups) > 0:
                yield ce.ThemeIdRepeated(dups)

        # chequea que un dataset no use un theme que no exista en la taxonomía
        # TODO: hay que implementarlo

        # chequea que un dataset no use theme con id esté repetido en taxonomía
        # TODO: hay que implementarlo

        # chequea que la extensión de fileName, downloadURL y format sean
        # consistentes
        for dataset_idx, dataset in enumerate(catalog["dataset"]):
            for distribution_idx, distribution in enumerate(
                    dataset["distribution"]):
                for attribute in ['downloadURL', 'fileName']:
                    if not format_matches_extension(distribution, attribute):
                        yield ce.ExtensionError(dataset_idx, distribution_idx,
                                                distribution, attribute)

        # chequea que no haya duplicados en los downloadURL de las
        # distribuciones
        # urls = []
        # for dataset in catalog["dataset"]:
        #     urls += [distribution['downloadURL']
        #              for distribution in dataset['distribution']
        #              if distribution.get('downloadURL')]
        # dups = _find_dups(urls)
        # if len(dups) > 0:
        #     yield ce.DownloadURLRepetitionError(dups)

        # chequea que las URLs de las distribuciones estén operativas
        # hay que revisar
        # for distribution in catalog.distributions:
        #     url = distribution.get("downloadURL")
        #     status_code = requests.head(url).status_code
        #     if status_code != 200:
        #         yield ce.DownloadURLBrokenError(
        #             distribution.get("identifier"), url, status_code)

    except Exception:
        logger.exception("Error de validación.")
766897
def ConsultarContribuyentes(self, fecha_desde, fecha_hasta, cuit_contribuyente):
        ""
        self.limpiar()
        try:

            self.xml = SimpleXMLElement(XML_ENTRADA_BASE)
            self.xml.fechaDesde = fecha_desde
            self.xml.fechaHasta = fecha_hasta
            self.xml.contribuyentes.contribuyente.cuitContribuyente = cuit_contribuyente

            xml = self.xml.as_xml()
            self.CodigoHash = md5.md5(xml).hexdigest()
            nombre = "DFEServicioConsulta_%s.xml" % self.CodigoHash

            # guardo el xml en el archivo a enviar y luego lo re-abro:
            archivo = open(os.path.join(tempfile.gettempdir(), nombre), "w")
            archivo.write(xml)
            archivo.close()
            archivo = open(os.path.join(tempfile.gettempdir(), nombre), "r")

            if not self.testing:
                response = self.client(user=self.Usuario, password=self.Password,
                                   file=archivo)
            else:
                response = open(self.testing).read()
            self.XmlResponse = response
            self.xml = SimpleXMLElement(response)
            if 'tipoError' in self.xml:
                self.TipoError = str(self.xml.tipoError)
                self.CodigoError = str(self.xml.codigoError)
                self.MensajeError = str(self.xml.mensajeError).decode('latin1').encode("ascii", "replace")
            if 'numeroComprobante' in self.xml:
                self.NumeroComprobante = str(self.xml.numeroComprobante)
                self.CantidadContribuyentes = int(self.xml.cantidadContribuyentes)
                if 'contribuyentes' in self.xml:
                    for contrib in self.xml.contribuyente:
                        c = {
                            'CuitContribuytente': str(contrib.cuitContribuyente),
                            'AlicuotaPercepcion': str(contrib.alicuotaPercepcion),
                            'AlicuotaRetencion': str(contrib.alicuotaRetencion),
                            'GrupoPercepcion': str(contrib.grupoPercepcion),
                            'GrupoRetencion': str(contrib.grupoRetencion),
                            'Errores': [],
                            }
                        self.contribuyentes.append(c)
                    # establecer valores del primer contrib (sin eliminarlo)
                    self.LeerContribuyente(pop=False)
            return True
        except Exception, e:
                ex = traceback.format_exception( sys.exc_type, sys.exc_value, sys.exc_traceback)
                self.Traceback = ''.join(ex)
                try:
                    self.Excepcion = traceback.format_exception_only( sys.exc_type, sys.exc_value)[0]
                except:
                    self.Excepcion = u"<no disponible>"
                return False
837798
def ConsultarCortes(self, sep="||"):
        ""
        ret = self.client.consultarCortes(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['respuesta']
        self.__analizar_errores(ret)
        array = ret.get('corte', []) + ret.get('cortePorcino', [])
        if sep is None:
            return dict([(it['codigo'], it['descripcion']) for it in array])
        else:
            return [("%s %%s %s %%s %s" % (sep, sep, sep)) %
                    (it['codigo'], it['descripcion']) for it in array]
832665
def ConsultarRetencionesTabacaleras(self, sep="||"):
        ""
        ret = self.client.consultarRetencionesTabacaleras(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['respuesta']
        self.__analizar_errores(ret)
        array = ret.get('retencion', [])
        if sep is None:
            return dict([(it['codigo'], it['descripcion']) for it in array])
        else:
            return [("%s %%s %s %%s %s" % (sep, sep, sep)) %
                    (it['codigo'], it['descripcion']) for it in array]