diff --git a/src/controllers/pendencias-controller.js b/src/controllers/pendencias-controller.js
index 8f8b5a9..d98ff5b 100644
--- a/src/controllers/pendencias-controller.js
+++ b/src/controllers/pendencias-controller.js
@@ -6,6 +6,7 @@ import subespecie from '../validators/subespecie';
 
 const {
     Alteracao,
+    Autor,
     Usuario,
     Herbario,
     Solo,
@@ -1306,208 +1307,338 @@ export const aprovarComJson = async (changes, hcf, response, next) => {
     // );
 };
 
-// export const aprovarComJsonNome = (alteracao, hcf, transaction) => {
-//     const parametros = {};
-
-//     return new Promise((resolve, reject) => Familia.findOne({
-//         where: {
-//             nome: { [Op.like]: `%${alteracao.familia_nome}%` },
-//         },
-//         transaction,
-//     })
-//         .then(familia => {
-//             if (familia) {
-//                 return familia;
-//             }
-//             return Familia.create({ nome: alteracao.familia_nome }, transaction);
-//         })
-//         .then(familia => {
-//             if (familia) {
-//                 parametros.familia = familia;
-//             }
-//             if (alteracao.subfamilia_nome) {
-//                 return Subfamilia.findOne({
-//                     where: {
-//                         nome: { [Op.like]: `%${alteracao.subfamilia_nome}%` },
-//                     },
-//                     transaction,
-//                 });
-//             }
-//             return undefined;
-//         })
-//         .then(subfamilia => {
-//             if (subfamilia) {
-//                 parametros.subfamilia = subfamilia;
-//             } else if (alteracao.subfamilia_nome) {
-//                 return Subfamilia.create({ nome: alteracao.subfamilia_nome }, transaction);
-//             }
-//             return undefined;
-//         })
-//         .then(subfamilia => {
-//             if (subfamilia) {
-//                 parametros.subfamilia = subfamilia;
-//             }
-//             if (alteracao.genero_nome) {
-//                 return Genero.findOne({
-//                     where: {
-//                         nome: { [Op.like]: `%${alteracao.genero_nome}%` },
-//                     },
-//                     transaction,
-//                 });
-//             }
-//             return undefined;
-//         })
-//         .then(genero => {
-//             if (genero) {
-//                 parametros.genero = genero;
-//             } else if (alteracao.genero_nome) {
-//                 return Genero.create({
-//                     where: {
-//                         nome: { [Op.like]: `%${alteracao.genero_nome}%` },
-//                     },
-//                     transaction,
-//                 });
-//             }
-//             return undefined;
-//         })
-//         .then(genero => {
-//             if (alteracao.genero_nome) {
-//                 parametros.genero = genero;
-//             }
-//             if (alteracao.especie_nome) {
-//                 return Especie.findOne({
-//                     where: {
-//                         nome: { [Op.like]: `%${alteracao.especie_nome}%` },
-//                     },
-//                     transaction,
-//                 });
-//             }
-//             return undefined;
-//         })
-//         .then(especie => {
-//             if (especie) {
-//                 parametros.especie = especie;
-//             } else if (alteracao.especie_nome) {
-//                 return Especie.create({
-//                     where: {
-//                         nome: { [Op.like]: `%${alteracao.especie_nome}%` },
-//                     },
-//                     transaction,
-//                 });
-//             }
-//             return undefined;
-//         })
-//         .then(especie => {
-//             if (alteracao.especie_nome) {
-//                 parametros.especie = especie;
-//             }
-//             if (alteracao.subespecie_nome) {
-//                 return Subespecie.findOne({
-//                     where: {
-//                         nome: { [Op.like]: `%${alteracao.subespecie_nome}%` },
-//                     },
-//                     transaction,
-//                 });
-//             }
-//             return undefined;
-//         })
-//         .then(subspecie => {
-//             if (subspecie) {
-//                 parametros.subespecie = subspecie;
-//             } else if (alteracao.subespecie_nome) {
-//                 return Subespecie.create({
-//                     where: {
-//                         nome: { [Op.like]: `%${alteracao.subespecie_nome}%` },
-//                     },
-//                     transaction,
-//                 });
-//             }
-//             return undefined;
-//         })
-//         .then(subspecie => {
-//             if (alteracao.subespecie_nome) {
-//                 parametros.subespecie = subspecie;
-//             }
-//             if (alteracao.variedade_nome) {
-//                 return Variedade.findOne({
-//                     where: {
-//                         nome: { [Op.like]: `%${alteracao.variedade_nome}%` },
-//                     },
-//                     transaction,
-//                 });
-//             }
-//             return undefined;
-//         })
-//         .then(variedade => {
-//             if (variedade) {
-//                 parametros.variedade = variedade;
-//             } else if (alteracao.variedade_nome) {
-//                 return Variedade.create({
-//                     where: {
-//                         nome: { [Op.like]: `%${alteracao.variedade_nome}%` },
-//                     },
-//                     transaction,
-//                 });
-//             }
-//             return undefined;
-//         })
-//         .then(variedade => {
-//             if (alteracao.variedade_nome) {
-//                 parametros.variedade = variedade;
-//             }
-//             const update = {};
-//             if (parametros.familia) {
-//                 update.familia_id = parametros.familia.id;
-//                 update.nome_cientifico = `${parametros.familia.nome} `;
-//             }
-//             if (parametros.subfamilia) {
-//                 update.sub_familia_id = parametros.subfamilia.id;
-//                 update.nome_cientifico += `${parametros.subfamilia.nome} `;
-//             }
-//             if (parametros.genero) {
-//                 update.genero_id = parametros.genero.id;
-//                 update.nome_cientifico += `${parametros.genero.nome} `;
-//             }
-//             if (parametros.especie) {
-//                 update.especie_id = parametros.especie.id;
-//                 update.nome_cientifico += `${parametros.especie.nome} `;
-//             }
-//             if (parametros.subespecie) {
-//                 update.sub_especie_id = parametros.subespecie.id;
-//                 update.nome_cientifico += `${parametros.subespecie.nome} `;
-//             }
-//             if (parametros.variedade) {
-//                 update.variedade_id = parametros.variedade.id;
-//                 update.nome_cientifico += `${parametros.variedade.nome}`;
-//             }
-//             return Tombo.update(update, {
-//                 where: {
-//                     hcf,
-//                     ativo: true,
-//                 },
-//                 transaction,
-//             });
-//         })
-//         .then(() => {
-//             resolve(true);
-//         })
-//         .catch(reject));
-// };
-
-// export const aprovarComCadastroJson = (alteracao, hcf, transaction) => true;
-
-// export const aprovarComCadastro = (hcf, transaction) => new Promise((resolve, reject) => Tombo.update({
-//     rascunho: 0,
-// }, {
-//     where: {
-//         hcf,
-//     },
-//     transaction,
-// })
-//     .then(() => {
-//         resolve(true);
-//     })
-//     .catch(reject));
+export const aprovarComJsonId = (alteracao, hcf, transaction) => {
+    const parametros = {};
+
+    return Tombo.findOne({
+        where: {
+            hcf,
+        },
+        transaction,
+    })
+        .then(tombo => {
+            parametros.tombo = tombo;
+        })
+        .then(() => {
+            if (alteracao.genero_nome) {
+                return Genero.findOrCreate({
+                    where: {
+                        nome: alteracao.genero_nome,
+                    },
+                    defaults: {
+                        nome: alteracao.genero_nome,
+                        familia_id: parametros.tombo.dataValues.familia_id,
+                        ativo: true,
+                    },
+                    attributes: ['id', 'nome'],
+                    transaction,
+                })
+                    .then(([genero]) => {
+                        parametros.genero = genero;
+                    });
+            }
+            return undefined;
+        })
+        .then(() => {
+            if (alteracao.especie_nome) {
+                const iniciais = alteracao.autor.match(/([A-Z])/g).join('.');
+                return Autor.findOrCreate({
+                    where: {
+                        nome: alteracao.autor,
+                    },
+                    defaults: {
+                        nome: alteracao.autor,
+                        iniciais,
+                        ativo: true,
+                    },
+                    attributes: ['id', 'nome', 'iniciais'],
+                    transaction,
+                })
+                    .then(([autor]) => Especie.findOrCreate({
+                        where: {
+                            nome: alteracao.especie_nome,
+                        },
+                        defaults: {
+                            nome: alteracao.especie_nome,
+                            genero_id: parametros.tombo.dataValues.genero_id,
+                            familia_id: parametros.tombo.dataValues.familia_id,
+                            autor_id: autor.id,
+                            ativo: true,
+                        },
+                        attributes: ['id', 'nome'],
+                        transaction,
+                    })
+                        .then(([especie]) => {
+                            parametros.especie = especie;
+                        }));
+            }
+            return undefined;
+        })
+        .then(() => {
+            if (alteracao.subfamilia_nome) {
+                return Subfamilia.findOne({
+                    where: {
+                        nome: alteracao.subfamilia_nome,
+                    },
+                    attributes: ['id', 'nome'],
+                    transaction,
+                })
+                    .then(subfamilia => {
+                        parametros.subfamilia = subfamilia;
+                    });
+            }
+            return undefined;
+        })
+        .then(() => {
+            if (alteracao.subespecie_nome) {
+                return Subespecie.findOne({
+                    where: {
+                        nome: alteracao.subespecie_nome,
+                    },
+                    attributes: ['id', 'nome'],
+                    transaction,
+                })
+                    .then(subEspecie => {
+                        parametros.subespecie = subEspecie;
+                    });
+            }
+            return undefined;
+        })
+        .then(() => {
+            if (alteracao.variedade_nome) {
+                return Variedade.findOne({
+                    where: {
+                        nome: alteracao.variedade_nome,
+                    },
+                    attributes: ['id', 'nome'],
+                    transaction,
+                })
+                    .then(variedade => {
+                        parametros.variedade = variedade;
+                    });
+            }
+            return undefined;
+        })
+        .then(() => parametros.tombo.update({
+            especie_id: parametros.especie ? parametros.especie.id : parametros.tombo.especie_id,
+            genero_id: parametros.genero ? parametros.genero.id : parametros.tombo.genero_id,
+            subfamilia_id: parametros.subfamilia ? parametros.subfamilia.id : parametros.tombo.subfamilia_id,
+            subespecie_id: parametros.subespecie ? parametros.subespecie.id : parametros.tombo.subespecie_id,
+            variedade_id: parametros.variedade ? parametros.variedade.id : parametros.tombo.variedade_id,
+        }, {
+            transaction,
+        }))
+        .then(() =>
+            Promise.all([
+                Genero.findOne({
+                    where: {
+                        id: parametros.tombo.genero_id,
+                    },
+                    attributes: ['nome'],
+                    transaction,
+                }),
+                Especie.findOne({
+                    where: {
+                        id: parametros.tombo.especie_id,
+                    },
+                    attributes: ['nome'],
+                    transaction,
+                }),
+            ])
+        )
+        .then(([genero, especie]) =>
+            parametros.tombo.update({
+                nome_cientifico: `${genero.nome} ${especie.nome}`,
+            }, {
+                transaction,
+            })
+        );
+};
+
+export const aprovarComJsonNome = (alteracao, hcf, transaction) => {
+    const parametros = {};
+
+    return Familia.findOne({
+        where: {
+            nome: { [Op.like]: `%${alteracao.familia_nome}%` },
+        },
+        transaction,
+    })
+        .then(familia => {
+            if (familia) {
+                return familia;
+            }
+            return Familia.create({ nome: alteracao.familia_nome }, transaction);
+        })
+        .then(familia => {
+            if (familia) {
+                parametros.familia = familia;
+            }
+            if (alteracao.subfamilia_nome) {
+                return Subfamilia.findOne({
+                    where: {
+                        nome: { [Op.like]: `%${alteracao.subfamilia_nome}%` },
+                    },
+                    transaction,
+                });
+            }
+            return undefined;
+        })
+        .then(subfamilia => {
+            if (subfamilia) {
+                parametros.subfamilia = subfamilia;
+            } else if (alteracao.subfamilia_nome) {
+                return Subfamilia.create({ nome: alteracao.subfamilia_nome }, transaction);
+            }
+            return undefined;
+        })
+        .then(subfamilia => {
+            if (subfamilia) {
+                parametros.subfamilia = subfamilia;
+            }
+            if (alteracao.genero_nome) {
+                return Genero.findOne({
+                    where: {
+                        nome: { [Op.like]: `%${alteracao.genero_nome}%` },
+                    },
+                    transaction,
+                });
+            }
+            return undefined;
+        })
+        .then(genero => {
+            if (genero) {
+                parametros.genero = genero;
+            } else if (alteracao.genero_nome) {
+                return Genero.create({
+                    where: {
+                        nome: { [Op.like]: `%${alteracao.genero_nome}%` },
+                    },
+                    transaction,
+                });
+            }
+            return undefined;
+        })
+        .then(genero => {
+            if (alteracao.genero_nome) {
+                parametros.genero = genero;
+            }
+            if (alteracao.especie_nome) {
+                return Especie.findOne({
+                    where: {
+                        nome: { [Op.like]: `%${alteracao.especie_nome}%` },
+                    },
+                    transaction,
+                });
+            }
+            return undefined;
+        })
+        .then(especie => {
+            if (especie) {
+                parametros.especie = especie;
+            } else if (alteracao.especie_nome) {
+                return Especie.create({
+                    where: {
+                        nome: { [Op.like]: `%${alteracao.especie_nome}%` },
+                    },
+                    transaction,
+                });
+            }
+            return undefined;
+        })
+        .then(especie => {
+            if (alteracao.especie_nome) {
+                parametros.especie = especie;
+            }
+            if (alteracao.subespecie_nome) {
+                return Subespecie.findOne({
+                    where: {
+                        nome: { [Op.like]: `%${alteracao.subespecie_nome}%` },
+                    },
+                    transaction,
+                });
+            }
+            return undefined;
+        })
+        .then(subspecie => {
+            if (subspecie) {
+                parametros.subespecie = subspecie;
+            } else if (alteracao.subespecie_nome) {
+                return Subespecie.create({
+                    where: {
+                        nome: { [Op.like]: `%${alteracao.subespecie_nome}%` },
+                    },
+                    transaction,
+                });
+            }
+            return undefined;
+        })
+        .then(subspecie => {
+            if (alteracao.subespecie_nome) {
+                parametros.subespecie = subspecie;
+            }
+            if (alteracao.variedade_nome) {
+                return Variedade.findOne({
+                    where: {
+                        nome: { [Op.like]: `%${alteracao.variedade_nome}%` },
+                    },
+                    transaction,
+                });
+            }
+            return undefined;
+        })
+        .then(variedade => {
+            if (variedade) {
+                parametros.variedade = variedade;
+            } else if (alteracao.variedade_nome) {
+                return Variedade.create({
+                    where: {
+                        nome: { [Op.like]: `%${alteracao.variedade_nome}%` },
+                    },
+                    transaction,
+                });
+            }
+            return undefined;
+        })
+        .then(variedade => {
+            if (alteracao.variedade_nome) {
+                parametros.variedade = variedade;
+            }
+            const update = {};
+            if (parametros.familia) {
+                update.familia_id = parametros.familia.id;
+                update.nome_cientifico = `${parametros.familia.nome} `;
+            }
+            if (parametros.subfamilia) {
+                update.sub_familia_id = parametros.subfamilia.id;
+                update.nome_cientifico += `${parametros.subfamilia.nome} `;
+            }
+            if (parametros.genero) {
+                update.genero_id = parametros.genero.id;
+                update.nome_cientifico += `${parametros.genero.nome} `;
+            }
+            if (parametros.especie) {
+                update.especie_id = parametros.especie.id;
+                update.nome_cientifico += `${parametros.especie.nome} `;
+            }
+            if (parametros.subespecie) {
+                update.sub_especie_id = parametros.subespecie.id;
+                update.nome_cientifico += `${parametros.subespecie.nome} `;
+            }
+            if (parametros.variedade) {
+                update.variedade_id = parametros.variedade.id;
+                update.nome_cientifico += `${parametros.variedade.nome}`;
+            }
+            return Tombo.update(update, {
+                where: {
+                    hcf,
+                    ativo: true,
+                },
+                transaction,
+            });
+        })
+        .then(() => true);
+};
 
 export const visualizarComJsonNome = (alteracao, hcf, transaction) => new Promise((resolve, reject) => {
     Tombo.findOne({
diff --git a/src/herbarium/comparainformacao.js b/src/herbarium/comparainformacao.js
index 9ec1104..57711bf 100644
--- a/src/herbarium/comparainformacao.js
+++ b/src/herbarium/comparainformacao.js
@@ -107,7 +107,7 @@ export function ehIgualFamilia(idFamilia, nomeFamiliaHerbarioVirtual) {
         }
         const processaNomeFamiliaBD = processaString(nomeFamiliaBd);
         const processaNomeFamiliaReflora = processaString(nomeFamiliaHerbarioVirtual);
-        if (processaNomeFamiliaBD === processaNomeFamiliaReflora) {
+        if (processaNomeFamiliaBD.toLowerCase() === processaNomeFamiliaReflora.toLowerCase()) {
             promessa.resolve(-1);
             return promessa.promise;
         }
@@ -158,7 +158,7 @@ export function ehIgualGenero(idGenero, nomeGeneroHerbarioVirtual) {
         }
         const processaNomeGeneroBd = processaString(nomeGeneroBd);
         const processaNomeGeneroReflora = processaString(nomeGeneroHerbarioVirtual);
-        if (processaNomeGeneroBd === processaNomeGeneroReflora) {
+        if (processaNomeGeneroBd.toLowerCase() === processaNomeGeneroReflora.toLowerCase()) {
             promessa.resolve(-1);
             return promessa.promise;
         }
@@ -209,7 +209,7 @@ export function ehIgualEspecie(idEspecie, nomeEspecieHerbarioVirtual) {
         }
         const processaNomeEspecieBd = processaString(nomeEspecieBd);
         const processaNomeEspecieReflora = processaString(nomeEspecieHerbarioVirtual);
-        if (processaNomeEspecieBd === processaNomeEspecieReflora) {
+        if (processaNomeEspecieBd.toLowerCase() === processaNomeEspecieReflora.toLowerCase()) {
             promessa.resolve(-1);
             return promessa.promise;
         }
diff --git a/src/herbarium/herbariumdatabase.js b/src/herbarium/herbariumdatabase.js
index cf58945..df20e25 100644
--- a/src/herbarium/herbariumdatabase.js
+++ b/src/herbarium/herbariumdatabase.js
@@ -17,6 +17,7 @@ import modeloEspecies from '../models/Especie';
 import modeloFamilias from '../models/Familia';
 import modeloGeneros from '../models/Genero';
 import modeloReflora from '../models/Reflora';
+import modeloSpecieslink from '../models/Specieslink';
 import modeloSubespecies from '../models/Subespecie';
 import modeloTombos from '../models/Tombo';
 import modeloTombosFotos from '../models/TomboFoto';
@@ -60,6 +61,20 @@ export function criaTabelaReflora() {
     return tabelaReflora;
 }
 
+/**
+ * A função criaTabelaSpecieslink, cria uma tabela chamada reflora,
+ * com base no modelo que foi chamado e dentro desse modelo,
+ * existe nome das colunas que estarão presentes nessa tabela.
+ * Nessa tabela é guardado os códigos de barras, e as respostas das requisições.
+ * Detalhe force: true é igual ao drop table.
+ * @return tabelaSpecieslink, que é a tabela que foi criada.
+ */
+export function criaTabelaSpecieslink() {
+    const tabelaSpecieslink = modeloSpecieslink(conexao, Sequelize);
+    tabelaSpecieslink.sync({ force: true });
+    return tabelaSpecieslink;
+}
+
 /**
  * A função selectTemExecucaoServico, realiza um consulta no banco de dados,
  * mas especificamente na tabela de configuracao, na qual é retornado registros
@@ -307,6 +322,39 @@ export function insereTabelaReflora(tabelaReflora, listaCodBarra) {
     return promessa.promise;
 }
 
+/**
+ * A função insereTabelaSpecieslink, percorre a lista que foi passada por parâmetro
+ * e a cada item dessa lista é adicionado o código de barra presente nessa
+ * lista na tabela do reflora. Um detalhe que vale a pena ressaltar é que
+ * Sem o throttle ele faz muitas conexões simultaneamente, acabando gerando
+ * erros. O throttle faz um por um, evitando erros. Algumas soluções no StackOverflow
+ * falavam para adicionar certas configurações na criação da conexão, porém nada deu certo.
+ * @param {*} tabelaSpecieslink, é a tabela do reflora aonde será adicionado os códigos de barra.
+ * @param {*} listaCodBarra, é a lista de códigos de barras que serão inseridos no
+ * banco de dados.
+ * @return promessa.promise, como é assíncrono ele só retorna quando resolver, ou seja,
+ * quando terminar de realizar a inserção.
+ */
+export function insereTabelaSpecieslink(tabelaSpecieslink, listaCodBarra) {
+    const throttle = throttledQueue(1, 200);
+    const promessa = Q.defer();
+    listaCodBarra.forEach((codBarra, index) => {
+        throttle(() => {
+            tabelaSpecieslink.create({
+                cod_barra: codBarra.dataValues.codigo_barra,
+                tombo_json: null,
+                ja_requisitou: false,
+                nro_requisicoes: 3,
+            }).then(() => {
+                if (index === listaCodBarra.length - 1) {
+                    promessa.resolve();
+                }
+            });
+        });
+    });
+    return promessa.promise;
+}
+
 /**
  * A função selectUmCodBarra, realiza uma consulta no banco de dados onde são
  * retornados apenas um registro da tabela onde o valor da coluna é zero (ou seja,
@@ -655,6 +703,26 @@ export function existeTabelaReflora() {
     return promessa.promise;
 }
 
+/**
+ * A função existeTabelaReflora, executa um SHOW TABLES verificando
+ * se existe a tabela do reflora ou não. Se existir a tabela do reflora
+ * retorna true, e caso não exista false.
+ * @return promessa.promise, como é assíncrono ele só retorna quando resolver, ou seja,
+ * quando terminar de realizar a consulta de verificar se existe ou não a tabela.
+ */
+export function existeTabelaSpecieslink() {
+    const promessa = Q.defer();
+    conexao.query('SHOW TABLES', { type: Sequelize.QueryTypes.SHOWTABLES }).then(listaTabelas => {
+        listaTabelas.forEach(tabelas => {
+            if (tabelas === 'specieslink') {
+                promessa.resolve(true);
+            }
+        });
+        promessa.resolve(false);
+    });
+    return promessa.promise;
+}
+
 /**
  * A função apagaTabelaReflora, executa um DROP TABLE, ou seja,
  * apagar uma tabela que no caso é a tabela do reflora.
diff --git a/src/herbarium/log.js b/src/herbarium/log.js
index 34ed489..9770ae5 100644
--- a/src/herbarium/log.js
+++ b/src/herbarium/log.js
@@ -57,8 +57,11 @@ export function transformaLog(conteudo) {
     const transformacaoUm = conteudo.replace(/\[/g, ' "[');
     const transformacaoDois = transformacaoUm.replace(/\./g, '." ,');
     const transformacaoTres = transformacaoDois.substring(0, transformacaoDois.lastIndexOf(','));
-    const transformacaoQuatro = `{ "log": [ ${transformacaoTres} ] }`;
-    return JSON.parse(transformacaoQuatro);
+
+    const jsonString = JSON.stringify(transformacaoTres);
+    const jsonObject = JSON.parse(jsonString);
+
+    return jsonObject;
 }
 
 /**
diff --git a/src/herbarium/reflora/tombos.js b/src/herbarium/reflora/tombos.js
index 2b293f9..ce418e7 100644
--- a/src/herbarium/reflora/tombos.js
+++ b/src/herbarium/reflora/tombos.js
@@ -68,6 +68,7 @@ export async function geraJsonAlteracao(nroTombo, codBarra, informacaoReflora) {
             await ehIgualGenero(processaInformacaoBd.genero_id, informacaoReflora.genus).then(genero => {
                 if (genero !== -1) {
                     alteracaoInformacao += `"genero_nome": "${genero}", `;
+                    alteracaoInformacao += `"autor": "${informacaoReflora.scientificnameauthorship}", `;
                 }
             });
         }
@@ -76,6 +77,7 @@ export async function geraJsonAlteracao(nroTombo, codBarra, informacaoReflora) {
             await ehIgualEspecie(processaInformacaoBd.especie_id, informacaoReflora.specificepithet).then(especie => {
                 if (especie !== -1) {
                     alteracaoInformacao += `"especie_nome": "${especie}", `;
+                    alteracaoInformacao += `"autor": "${informacaoReflora.scientificnameauthorship}", `;
                 }
             });
         }
diff --git a/src/models/Specieslink.js b/src/models/Specieslink.js
new file mode 100644
index 0000000..9898ae5
--- /dev/null
+++ b/src/models/Specieslink.js
@@ -0,0 +1,46 @@
+function associate(/* modelos */) {
+}
+
+export default (Sequelize, DataTypes) => {
+
+    const attributes = {
+        id: {
+            type: DataTypes.INTEGER,
+            autoIncrement: true,
+            primaryKey: true,
+        },
+        cod_barra: {
+            type: DataTypes.STRING(12),
+            allowNull: true,
+        },
+        tombo_json: {
+            type: DataTypes.TEXT,
+            allowNull: true,
+        },
+        ja_comparou: {
+            type: DataTypes.BOOLEAN,
+            defaultValue: false,
+        },
+        ja_requisitou: {
+            type: DataTypes.BOOLEAN,
+            defaultValue: false,
+        },
+        nro_requisicoes: {
+            type: DataTypes.INTEGER,
+            defaultValue: false,
+        },
+    };
+
+    const options = {
+        freezeTableName: false,
+        // Disabilita o created_at e updated_at
+        timestamps: false,
+        tableName: 'specieslink',
+    };
+
+    const Model = Sequelize.define('specieslink', attributes, options);
+
+    Model.associate = associate;
+
+    return Model;
+};