<file_sep>var express = require('express');
var router = express.Router();
var Obras= require('../controllers/obras')


router.get('/obras', function(req, res) {
  let compositor= req.query.compositor
  let instrumento = req.query.instrumento
  //var chaves = req.params.id.split('&')
  if(compositor){
    Obras.listarFromCompositor(compositor)
          .then(dados => res.jsonp(dados))
          .catch(error => res.status(500).jsonp(error))
  }
  else if(instrumento){
    Obras.listarObrasInstrumento(instrumento)
          .then(dados => res.jsonp(dados))
          .catch(error => res.status(500).jsonp(error))
  }
  else{
    Obras.listar()
          .then(dados => res.jsonp(dados))
          .catch(error => res.status(500).jsonp(error))
      }
});

router.get('/obras/:id', function(req, res) {
  //var chaves = req.params.id.split('&')
  Obras.consultar(req.params.id)
        .then(dados => res.jsonp(dados))
        .catch(error => res.status(500).jsonp(error))
});

router.get('/tipos', function(req, res) {
  //var chaves = req.params.id.split('&')
  Obras.listarTipos()
        .then(dados => res.jsonp(dados))
        .catch(error => res.status(500).jsonp(error))
});

router.get('/obrasQuant', function(req, res) {
  //var chaves = req.params.id.split('&')
  Obras.listarObrasPartiturasQuantidade() 
        .then(dados => res.jsonp(dados))
        .catch(error => res.status(500).jsonp(error))
});

router.get('/*', function(req, res) {
  res.status(500).jsonp();
});

router.post('/*', function(req, res) {
  res.status(500).jsonp();
});

router.put('/*', function(req, res) {
  res.status(500).jsonp();
});

router.delete('/*', function(req, res) {
  res.status(500).json();
});


module.exports = router;
<file_sep>function apagarMusica(id){
    console.log('Vou tentar apagar o ' + id + '....')
    axios.delete('/musica/' + id)
        .then(response => window.location.assign('/'))
        .catch(error => console.log(error))
}<file_sep>var Obras = require('../models/obras')
var mongoose = require('mongoose');
const ObjectId = mongoose.Types.ObjectId

module.exports.listar = () =>{
    return Obras
                .find()
                .exec()
}

module.exports.listarByAno = (ano) => {
    return Obras
                .find({anoCriacao: ano})
                .exec()
}

module.exports.listarByCompositorDuracao = (comp, dur) => {
    return Obras
                .find({$and : {compositor: comp, duracao: dur}})
                .exec()
}
module.exports.listarByPeriodo = (ano) => {
    return Obras
                .find({perido: {$gt: data}})
                .exec()
}

module.exports.consultar = (id) => {
    return Obras
                .findOne({_id: id})
                .exec()
}

module.exports.listarCompositores = () => {
    return Obras 
                .distinct("compositor")
                .exec()
}
module.exports.listarPeriodos = () => {
    return Obras
                .distinct("periodo")
                .exec()
}<file_sep>var Premios = require('../models/premios')
var mongoose = require('mongoose');
const ObjectId = mongoose.Types.ObjectId

//Devolve a lista de alunos
module.exports.listar = () =>{
    return Premios
                .find()
                .select({year:1, category:1})
                .exec()
}

module.exports.listarC = category =>{
    return Premios
                .find({category: category})
                .exec()
}

module.exports.listarCD = (categoria, data) =>{
    return Premios
                .find({year: {$gt: data}, category: categoria})
                .exec()
}

module.exports.listarLaureados = () =>{
    return Premios
                .aggregate([{$unwind: "$laureates"}, 
                            {$group: 
                                {_id: "$laureates.id", 
                                firstname:{$first: "$laureates.firstname"},
                                surname:{$first: "$laureates.surname"},
                                prize: 
                                        {$push: 
                                            {year:"$year", category:"$category"}
                                        }
                                }
                            },
                            {$project: 
                                {firstname:1, surname:1, prize:1, _id:0}
                            }
                        ])
                .sort({firstname:1, surname:1})
                .exec()
  }
  

module.exports.consultar = id =>{
    return Premios
                .findOne({_id: ObjectId(id)})
                .exec()
}

module.exports.listarCategorias = () =>{
    return Premios.distinct('category').exec()
}

<file_sep>var Filme = require('../models/filme')
const mongoose = require('mongoose')
const ObjectId =  mongoose.Types.ObjectId

const Filmes = module.exports

Filmes.listar  = () =>{
    return Filme
            .find()
            .sort({title:1})
            .exec()
}

Filmes.apagar = id => {
    return Filme
            .findOneAndDelete({_id: ObjectId(id)})
            .exec()
            
}

Filmes.consultar  = id =>{
    return Filme
            .findOne({_id: ObjectId(id)})
            .exec()
}

Filmes.adicionar = dados => {
    var filme = new Filme(dados)
    return filme.save({useFindAndModify : false})
}

Filmes.modificar = (id, dados) => {
    return Filme.findOneAndUpdate({_id: ObjectId(id)}, dados)
                .exec()
                //ver se dá
}

Filmes.contar = () =>{
    return Film.countDocuments().exec()
}

Filmes.listarPagina = (page) => {
    return Filme
        .find({}, {})
        .skip((page)*30)
        .limit(30)
        .sort({title:1})
        .exec()
}
<file_sep>var http = require('http')
var url = require('url')
var fs = require('fs')


http.createServer(function (req, res) {
    var partes = req.url.split('/')
    var qstr = partes[partes.length - 1]
    var str = qstr.split('.')

    var contentType = str[partes.length - 1]
    if(contentType == undefined)
        sender(res, 'dataset/arq' + qstr + '.xml', "text/xml");
    else
        if(contentType == "ico" | contentType == "gif")
            sender(res,'dataset/' + qstr, contentType)
        else
            sender(res, qstr, contentType )
}).listen(12345)

console.log('Servidor à escuta na porta 12345.....')

function sender(res, path, type){
    fs.readFile(path, function(err, data){
        if(err) {
            console.log(path);
            erro(res);
        }
        else{
            res.writeHead(200, {'Content-Type': type})
            res.write(data)
            res.end()
            }
        })
}

function erro(res){
    res.writeHead(404, {'Content-Type':'text/text'})
    res.write("Não foi possível encontrar o ficheiro requirido")
    res.end()
}<file_sep>var Obras = require('../models/obra')

//Devolve a lista de alunos
module.exports.listar = () =>{
    return Obras
                .find()
                .select({id:1, title:1, compositor:1, tipo:1, _id:0})
                .exec()
}

module.exports.consultar = id =>{
    return Obras
                .findOne({id: id})
                .exec()
}


module.exports.listarTipos = () => {
    return Obras
                .distinct('tipo')
                .exec()
}


module.exports.listarFromCompositor = compositor =>{
    return Obras
                .find({compositor: compositor})
                .exec()
}


module.exports.listarObrasInstrumento = instrumento =>{
    return Obras
                .find({"instrumentos.designacao": instrumento})
                .exec()
}


module.exports.listarObrasPartiturasQuantidade = () =>{
    return Obras
                .aggregate([{$unwind : "$instrumentos"},
                            {$group: 
                                {_id : "$id",
                                partituras: {$sum: 1},
                                titulo: {$first: "$titulo"}}},
                        ])
}




<file_sep><?xml version="1.0" encoding="UTF-8"?><html>
   <head>
      <title>Página de um arqueosítio</title>
      <meta charset="UTF8"></meta>
      <link rel="stylesheet" href="https://www.w3schools.com/w3css/4/w3.css"></link>
   </head>
   <body>
      <div class="w3-container">
         <h1>Monte da Saia; Cidade da citânia; Monte de Fralães </h1>
         <h3>Imagem</h3>
         <img src="" alt=" em falta!"></img>
         <h3>Descrição</h3>
         			 Povoado
         fortificado
         		
         <h3>Informações de localização</h3>
         <table class="w3-table">
            <tr>
               <th width="10%">Cronologia:</th>
               <td> Proto-História / Romanização</td>
            </tr>
            <tr>
               <th>Lugar:</th>
               <td> Monte da Saia </td>
            </tr>
            <tr>
               <th>Freguesia:</th>
               <td></td>
            </tr>
            <tr>
               <th>Concelho:</th>
               <td> Barcelos </td>
            </tr>
            <tr>
               <th>Latitude:</th>
               <td> 498,8 </td>
            </tr>
            <tr>
               <th>Longitude:</th>
               <td> 162,1 </td>
            </tr>
            <tr>
               <th>Altitude</th>
               <td> 303m </td>
            </tr>
         </table>
         <hr></hr>
         <h3>Acesso</h3>
         <p>O acesso pode fazer-se a partir de Chorente, ou Chavão, por caminho
            carreteiro.
         </p>
         <hr></hr>
         <h3>Quadro</h3>
         <p>O Monte da Saia situa-se no limite da bacia do Cávado, com a bacia do rio
            Este. Na sua vertente NE nasce o rio Covo, que corre para o Cávado; a Este,
            Sul e Oeste correm vários subafluentes do rio Este. O monte corresponde a
            uma elevação de altitude média, que ocupa uma posição de destaque no relevo
            da região. 
         </p>
         <hr></hr>
         <h3>Autor</h3>
         <p> <NAME> </p>
         <hr></hr>
         <h3>Bibliografia</h3>
         <p><NAME>. (1876). As ruínas existentes no Monte da Saia, Comércio do Lima,
            no 52, 22/11/1876. 
         </p>
         <p><NAME>. (1877) As ruínas existentes no Monte da Saia, Comércio do Lima,
            no 59, 10/1/1877. 
         </p>
         <p><NAME>. (1903). Cidade velha de Santa Luzia, Arqueólogo
            Português, 8, pp. 376, 379. 
         </p>
         <p><NAME>. (1913). Religiões da Lusitânia, III, Lisboa. pp.510-512;</p>
         <p><NAME>. (1948). O concelho de Barcelos Aquém e Além Cávado, Barcelos, 2
            vol. pp. 121. 
         </p>
         <p><NAME> (1968). Câmaras funerárias de la Cultura Castrena, Arquivo
            Español de Arqueologia, Madrid, 44 (117-118), pp.33-34; 
         </p>
         <p><NAME>. (1980b). Zur Atlantichen Bronzezeit in Portugal, Germania, 58,
            Frankfurt, no. 17. 
         </p>
         <p><NAME>. (1990). O Povoamento Proto-Histórico e a Romanização da Bacia do
            Médio Cávado, Cadernos de Arqueologia - Monografias, 5, Universidade do
            Minho, Braga, pp. 74. 
         </p>
         <hr></hr>
         <h3>Deposito</h3>
         <p> Museu Nacional de Arqueologia e Etnologia.</p>
         <hr></hr>
         <h3>Desenho Arquitetural</h3>
         <p>O povoado nunca foi objecto de escavações arqueológicas sistemáticas, sendo
            conhecido, sobretudo, a partir de achados ocorridos, ou no seu interior, ou
            nas suas imediações. Possui pelo menos três linhas de muralhas e na sua
            superfície recolheram-se abundantes fragmentos de  cerâmica micácea, de fabrico indígena e de cerâmica romana.
            Nele foi ainda identificado um  monumento
            com forno, do mesmo género dos descobertos em Briteiros e em Santa
            Maria dos Galegos, este último, também no concelho de Barcelos. J. Leite de
            Vasconcelos publicou duas  estelas aparecidas no
            sítio do Forno dos Mouros, numa das encostas do monte. Possuem um nicho, com
            figuras togadas; as peças deveriam estar relacionadas com o monumento e com
            o forno.
         </p>
         <hr></hr>
         <h3>Interesse</h3>
         <hr></hr>
         <h3>Interpretação</h3>
         <p>
            			 Povoado fortificado
            romananizado.
         </p>
         <hr></hr>
         <h3>Trabalhos no Arquiosítio</h3>
         <hr></hr>
         <h5>Data</h5>04-Fev-1998
         <hr></hr>
         <address>
            <a href="../website.html#d1e795">Voltar à página principal</a>
         </address>
         <hr></hr>
      </div>
   </body>
</html><file_sep>var mongoose = require('mongoose');
var jsonfile = require('jsonfile');

mongoImport = function (dataBaseName, collectionName, fileName){
    mongoose.connect('mongodb://127.0.0.1:27017/' + dataBaseName, {useNewUrlParser: true, useUnifiedTopology: true})
        .then(() => {
            jsonfile.readFile(fileName, (error, data) =>{
                if(error){
                    console.log("Read file error")
                    return
                }
                else{
                    let newSchema = mongoose.Schema({}, {strict:false})
                    let newModel = mongoose.model(collectionName, newSchema)
                    let newObj = new newModel(data)
                    newObj.save()
                        .then(data => {
                            console.log("Success")
                            mongoose.connection.close()})
                        .catch(error => console.log(error.message))
                }
            })
        })
        .catch(error => console.log("Unable to connect: " + error.message))
}
main = function (){
    if(process.argv.length != 5){
        console.log("Number of arguments invalid")
        return
    }
    let dataBaseName = process.argv[2]
    let collectionName = process.argv[3]
    let fileName = process.argv[4]
    mongoImport(dataBaseName, collectionName, fileName)
}

main()
<file_sep>var http = require('http')
var url = require('url')
var pug = require('pug')
var fs = require('fs')
var jsonfile = require('jsonfile')

var {parse} = require('querystring') //só exporta o parsing
var myBD = "tarefas.json"

var myServer = http.createServer((req,res) => {
    var purl = url.parse(req.url, true)
    var query = purl.query

    console.log(req.method + ' ' + purl.pathname)

    if(req.method == 'GET'){
        if((purl.pathname == '/') || (purl.pathname == '/gestaoTarefas')){
            jsonfile.readFile(myBD, (erro, tarefas) =>{
                res.writeHead(200, {'Content-Type': 'text/html; charset=utf-8'})
                if(erro){
                    res.write(pug.renderFile('erro.pug', {e: "Erro na leitura da BD...."}))
                    res.end();
                    console.log("erro no get")
                    return
                }
                setExpireDate(tarefas)
                res.write(pug.renderFile('front-page.pug', {lista: tarefas}))
                res.end();
                console.log("get com sucesso")
            })
        }
        else if(purl.pathname == '/w3.css'){
                res.writeHead(200, {'Content-Type': 'text/css'})
                fs.readFile('stylesheets/w3.css', (erro, dados) =>{
                    if(erro){
                        res.write(pug.renderFile('erro.pug', {e: "Stylesheet não encontrada...."}))
                        res.end()
                        console.log("erro de styleshet")
                        return
                    }
                    console.log("getting stylesheets")
                    res.write(dados)
                    res.end()
                })   
        }
        else if(purl.pathname == '/apagaVelhas.js'){
            res.writeHead(200, {'Content-Type': 'text/javascript'})
            fs.readFile('apagaVelhas.js', (erro, dados) =>{
                if(erro){
                    res.write(pug.renderFile('erro.pug', {e: "Script não encontrado...."}))
                    res.end()
                    console.log("erro de styleshet")
                    return
                }
                console.log("getting script")
                res.write(dados)
                res.end()
            })   
    }
            else {
                console.log("erro de path 2")
                res.writeHead(200, {
                    'Content-Type' : 'text/html; charset=utf-8'
                })
                res.write(pug.renderFile('erro.pug', {e: "ERRO: O método " + req.method + " não suporta o caminho " +
                                    purl.pathname}))
                res.end();
                }
    }
    else if(req.method == 'POST'){
            if(purl.pathname == '/tarefa'){
                recuperaInfo(req, resultado => {
                    jsonfile.readFile(myBD, (erro, tarefas) =>{
                        if(!erro){
                            tarefas.push(resultado)
                            jsonfile.writeFile(myBD, tarefas, erro2 => {
                                if(erro2)
                                    console.log(erro) //TODO mandar html e no de baixo tbm (DELETE)
                                else{
                                    console.log("refresh")
                                    res.writeHead(303, {'Location': '/'})
                                    res.end()
                                }
                            })
                        }
                    })
                })
            }
           else{
            res.writeHead(200, {
                'Content-Type' : 'text/html; charset=utf-8'
            })
            res.write(pug.renderFile('erro.pug', {e: "ERRO: O método " + req.method + " não suporta o caminho " +
                                    purl.pathname}))
            res.end();
           }
        }
    else if(req.method == "DELETE"){
            if(purl.pathname == '/tarefasvelhas'){
                jsonfile.readFile(myBD, (erro, tarefas) =>{
                    if(!erro){
                        tarefasfaziveis = filter(tarefas)
                        jsonfile.writeFile(myBD, tarefasfaziveis, erro2 =>{
                            if(erro2)
                                console.log(erro)
                            else{
                                res.writeHead(303, {'Location': '/'})
                                res.end()
                            }
                        })
                    }
                })
            }
            else{
                res.writeHead(200, {
                    'Content-Type' : 'text/html; charset=utf-8'
                })
                res.write(pug.renderFile('erro.pug', {e: "ERRO: O método " + req.method + " não suporta o caminho " +
                                        purl.pathname}))
                res.end();
               }
        }
        else{
            console.log("ERRO: " + req.method + " não suportado....")
            res.writeHead(200, {
                'Content-Type' : 'text/html; charset=utf-8'
            })
            res.write(pug.renderFile('erro.pug', {e: "ERRO: " + req.method + " não suportado...."}))
            res.end();
        }
})

myServer.listen(12345, ()=>{
    console.log("Servidor à escuta na porta 12345")
})

function setExpireDate(tarefas){
    for(tarefa of tarefas){
        var t = new Date(tarefa.data_limite) - Date.now()
        var d = Math.abs(Math.ceil(t/(1000 * 60 * 60 * 24)))
        if(d == 0){
            d += " dias. Está quase a acabar o tempo!"
        } 
        else{
            d += " dias. Está tranquilo"
            if(t < 0 ){
                d += " atrás. Já foste..."
            }
        }
        tarefa.tempo_restante = d
    }
}
function recuperaInfo(request, callback){
    if(request.headers['content-type'] == 'application/x-www-form-urlencoded'){
        let body = ''
        //enquanto conseguirmos ler dados do request
        request.on('data', bloco => {
            body += bloco.toString()
        })
        request.on('end', ()=> {
            callback(parse(body))
        })
    }
}


function filter(tarefas){
    var res = new Array();
    var length = tarefas.length;
    var localDate = new Date();
    console.dir(localDate);
    for(var j = 0; j < length; j++)
    {
        var objDate = Date.parse(tarefas[j].data_limite)
        console.dir(objDate)
        if(localDate <= objDate)
        {   
            console.log("if")
            res.push(tarefas[j])
        }
    }
    console.log(res);
    return res
}<file_sep>var express = require('express');
var router = express.Router();
var axios = require('axios')

router.get('/', function(req, res) {
    let path = 'http://localhost:3000/api/laureados';
    axios.get(path)
        .then(dados =>{
        res.render('lista-laureados', {lista : dados.data})
        })
        .catch(erro =>{
        res.render('error', {error: erro})
        })
    })
    
router.get('/*', function(req, res) {
  res.render('error', {error: "O método GET não suporta esse caminho"})
});

module.exports = router;<file_sep>var express = require('express');
var router = express.Router();
var axios = require('axios')

let apikey = <KEY>";

/* GET home page. */
router.get('/', function(req, res, next) {
  axios.get('http://clav-api.dglab.gov.pt/api/entidades' + apikey)
    .then(dados => {
      res.render('lista-entidades', {entidades : dados.data})
    })
    .catch(erro => {
      res.render('error', {error: erro})
    })
});

router.get('/tipologia/:id', function(req, res, next) {
  var id = req.params.id;
  axios.get('http://clav-api.dglab.gov.pt/api/tipologias/'+ id + apikey)
    .then(tipologia => {
        axios.get('http://clav-api.dglab.gov.pt/api/tipologias/'+ id + '/elementos' + apikey)
          .then(elementos => {
            axios.get('http://clav-api.dglab.gov.pt/api/tipologias/'+ id + '/intervencao/dono' + apikey)
              .then(dono => {
                axios.get('http://clav-api.dglab.gov.pt/api/tipologias/'+ id + '/intervencao/participante' + apikey)
                  .then(participante => {
                    res.render('tipologia', {tipologia: tipologia.data, elementos: elementos.data, dono: dono.data, participante: participante.data})
                  })
                  .catch(erro => {res.render('error', {error: erro})})
              }).catch(erro => {res.render('error', {error: erro})})
              .catch(erro => {res.render('error', {error: erro})})  
          }).catch(erro => {res.render('error', {error: erro})
        })
    }).catch(erro => {res.render('error', {error: erro})
    })
});


router.get('/entidade/:id', function(req, res, next) {
  axios.get('http://clav-api.dglab.gov.pt/api/entidades/' + req.params.id + apikey)
  .then(entidade =>{
    axios.get('http://clav-api.dglab.gov.pt/api/entidades/' + req.params.id + '/intervencao/dono' + apikey)
    .then(dono =>{
      axios.get('http://clav-api.dglab.gov.pt/api/entidades/' + req.params.id + '/intervencao/participante' + apikey)
      .then(participante =>{
        axios.get('http://clav-api.dglab.gov.pt/api/entidades/' + req.params.id + '/tipologias' + apikey)
        .then(tipologias =>{
          res.render('entidade', {entidade: entidade.data, dono: dono.data, participante: participante.data, tipologias: tipologias.data})
        }).catch(erro =>{res.render('error', {error: erro})
        })
      }).catch(erro =>{res.render('error', {error: erro})
      })
    }).catch(erro =>{res.render('error', {error: erro})
    })
  }).catch(erro =>{ res.render('error', {error: erro})
  })
});

router.get('/*', function(req, res) {
  res.render('error', {error: "O método GET não suporta esse caminho"})
});

router.post('/*', function(req, res) {
  res.render('error', {error: "O método POST não suporta esse caminho"})
});

router.put('/*', function(req, res) {
  res.render('error', {error: "O método PUT não suporta esse caminho"})
});

router.delete('/*', function(req, res) {
  res.render('error', {error: "O método DELETE não suporta esse caminho"})
});

module.exports = router;
<file_sep><html>
<head>
<META http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>
                        Project-Record 
                    </title>
<meta charset="UTF8">
<link rel="stylesheet" href="https://www.w3schools.com/w3css/4/w3.css">
</head>
<body>
<div class="w3-container">
<h1 class="w3-center">Project Record</h1>
</div>
    <div class="w3-container">
<hr>
<table class="w3-table">
<tr>
<td><b>KEY NAME: </b>TP9</td>
</tr>
<tr>
<td><b>TITLE: </b>Implementação de uma ferramenta semelhante ao mongoimport, mas utilizando nodejs e mongoose</td>
</tr>
<tr>
<td><b>BEGIN DATE: </b>novembro 2019</td>
</tr>
<tr>
<td><b>End Date: </b>novembro 2019</td>
</tr>
<tr>
<td><b>SUPERVISOR: </b><a href="https://www.di.uminho.pt/~jcr"><NAME></a></td>
</tr>
</table>
<hr>
</div>
    <div class="w3-container">
<h2>Workteam</h2>
<table class="w3-table w3-striped">
<tr>
<th>Identifier</th>
<th>Name</th>
<th>Email</th>
<th>Git</th>
</tr>
        <tr>
<td>81736</td>
<td><NAME></td>
<td><EMAIL></td>
<td>https://github.com/Dantas198</td>
</tr>
    </table>
<hr>
</div>
    <div class="w3-container">
<h2>Abstract</h2>
        <p>
            Criação de um executável que irá importar uma base de dados a partir de um ficheiro JSON. Isto é feito através da criação de 
            um esquema vazio e com uma estrutura não rígida e a partir dele é criado um modelo com o nome da coleção, para depois ser guardado
            com os dados obtidos a partir de um leitura do ficheiro JSON.
        </p>
    <hr>
</div>
    <div class="w3-container">
<h2>Deliverables</h2>
<ol>
        <li><a href="../mongoImport.js">Ficheiro com o código fonte para correr o comando</a></li>
    </ol>
<hr>
</div>
</body>
</html>
<file_sep>var jsonfile = require('jsonfile')
var nanoid = require('nanoid')
var myDB = __dirname + '/../../arq.json'

jsonfile.readFile(myDB, (erro, musicas) => {
    if(!erro){
        putIds(musicas)
        jsonfile.writeFile(myDB, musicas, erro =>{
            if(erro){
                console.log("Não foi possivel escrever")
                console.dir(erro);
            }
            else
                console.log("Sucesso")
        })
    }
    else    
        console.log("Erro a abriro ficheiro")})

function putIds(lista){
  for(musica of lista){
    musica.id = nanoid();
  }
}<file_sep>var mongoose = require('mongoose');

var partituraSchema = new mongoose.Schema({
    path: String,
    voz: String
})

var instrumentoSchema = new mongoose.Schema({
    designacao: String,
    partitura: partituraSchema
});

var obraSchema = new mongoose.Schema({
    id: String,
    titulo: String,
    tipo:String,
    compositor:String,
    instrumentos: [instrumentoSchema]
});

module.exports = mongoose.model('obras', obraSchema);<file_sep><?xml version="1.0" encoding="UTF-8"?><html>
   <head>
      <title>Página de um arqueosítio</title>
      <meta charset="UTF8"></meta>
      <link rel="stylesheet" href="https://www.w3schools.com/w3css/4/w3.css"></link>
   </head>
   <body>
      <div class="w3-container">
         <h1> Paredes </h1>
         <h3>Imagem</h3>
         <img src="" alt=" em falta!"></img>
         <h3>Descrição</h3> Ponte; Calçada 
         <h3>Informações de localização</h3>
         <table class="w3-table">
            <tr>
               <th width="10%">Cronologia:</th>
               <td> Idade Média</td>
            </tr>
            <tr>
               <th>Lugar:</th>
               <td> Ponte Velha </td>
            </tr>
            <tr>
               <th>Freguesia:</th>
               <td></td>
            </tr>
            <tr>
               <th>Concelho:</th>
               <td> Montalegre </td>
            </tr>
            <tr>
               <th>Latitude:</th>
               <td> 519,8 </td>
            </tr>
            <tr>
               <th>Longitude:</th>
               <td> 211,8 </td>
            </tr>
            <tr>
               <th>Altitude</th>
               <td> 830m </td>
            </tr>
         </table>
         <hr></hr>
         <h3>Acesso</h3>
         <p>Sobre a Corga de Caniçó, a menos de 500 metros para Sul da aldeia de
            Paredes. O acesso faz-se a pé (cerca de 10 minutos), por caminho carreteiro,
            a partir da aldeia de Paredes. A esta acede-se por estradão de terra batida,
            a partir da estrada municipal que liga Salto a Ruivães por Zebral. O
            monumento não está sinalizado.
         </p>
         <hr></hr>
         <h3>Quadro</h3>
         <hr></hr>
         <h3>Autor</h3>
         <p> <NAME> </p>
         <hr></hr>
         <h3>Bibliografia</h3>
         <p>COSTA, J.G.(1968). Montalegre e Terras de Barroso. Montalegre, 1968.</p>
         <p> FONTES, L.(1992). Sítios e Achados Arqueológicos do Concelho de
            Montalegre. Braga, 1992 (edição policopiada da CCRN - Porto). 
         </p>
         <hr></hr>
         <h3>Deposito</h3>
         <hr></hr>
         <h3>Desenho Arquitetural</h3>
         <p>Entre Caniçó e Torrinheiras conserva-se o traçado da via medieval que dava
            ligação a  cabeceiras de Basto. Até à Senhora
            dos Aflitos e sobretudo nas proximidades da aldeia de Paredes, conservam-se
            amplos troços de via lajeada, com 2,5m de largura média. Passa sobre a Corga
            de Caniçó, a cerca de 300 metros para Sul de Paredes, através de uma ponte
            de pedra de tradição arquitectónica medieval, com tabuleiro em cavalete
            sobre um arcode volta perfeita, bem aparelhado com
             silhares. Exceptuando a ponte, que necessita
            ser limpa e restaurada, a calçada e a envolvência paisagística, com relevo
            para o tradicional ordenamento agrário da veiga, apresentam-se muito bem
            conservadas.
         </p>
         <hr></hr>
         <h3>Interesse</h3>
         <p>Embora não possua um significativo valor patrimonial, este monumento tem
            muito interesse para a compreensão da rede de comunicações medieval,
            oferecendo simultaneamente um elevado potencial para a implementação de
            circuitos pedonais.
         </p>
         <hr></hr>
         <h3>Interpretação</h3>
         <p>Ponte e calçada medievais.</p>
         <hr></hr>
         <h3>Trabalhos no Arquiosítio</h3>
         <hr></hr>
         <h5>Data</h5>04-FEV-1998
         <hr></hr>
         <address>
            <a href="../website.html#d1e8298">Voltar à página principal</a>
         </address>
         <hr></hr>
      </div>
   </body>
</html><file_sep>function editaMusica(id){ 
    console.log('Vou tentar apagar o ' + id + '....')  
    
    file = {
      '@t': document.getElementById('6').value,
      '#text': document.getElementById('7').value
    }
    
    params = {
        id: id,
        tit:  document.getElementById('1').value,
        duracao: document.getElementById('2').value,
        prov: document.getElementById('3').value,
        local: document.getElementById('4').value,
        musico: document.getElementById('5').value,
        file
      }
    axios.put('/musica/' + id, params)
        .then(response =>  window.location.assign('/'))
        .catch(error => console.log(error))
}
