getLatestMetadataEntry()

in source/api/services/package/lib/metadata.js [159:253]

• 65 lines of code
• 9 McCabe index (conditional complexity)

                    getLatestMetadataEntry(packageId, function(err, latest) {

                        let _postedMetadata = {};
                        try {
                            if (typeof packageMetadata === 'string') {
                                _postedMetadata = JSON.parse(packageMetadata);
                            } else {
                                _postedMetadata = packageMetadata;
                            }
                        } catch (ex) {
                            return cb({
                                error: {
                                    message: 'Invalid json provided when attempting to create metadata.'
                                }
                            }, null);
                        }

                        let _newMetadata = {
                            package_id: packageId,
                            metadata_id: shortid.generate(),
                            created_at: moment.utc().format(),
                            created_by: ticket.userid,
                            metadata: []
                        };

                        for (let i = 0; i < _postedMetadata.metadata.length; i++) {
                            let _tagCheck = v.validate(_postedMetadata.metadata[i], tagSchema);
                            if (_tagCheck.valid) {
                                _newMetadata.metadata.push({
                                    tag: _postedMetadata.metadata[i].tag,
                                    value: _postedMetadata.metadata[i].value
                                });
                            } else {
                                return cb({
                                    error: {
                                        message: 'Invalid schema provided when attempting to create metadata.'
                                    }
                                }, null);
                            }
                        }

                        // existing metadata entries. Add or update existing entries
                        if (!_.isEmpty(latest)) {
                            // loop through last metadata entry and see if the tags exist in the new entry
                            // to ensure metadata is immutable
                            for (let i = 0; i < latest.metadata.length; i++) {
                                let _exist = _.find(_newMetadata.metadata, function(item) {
                                    return item.tag === latest.metadata[i].tag;
                                });

                                //add if doesn't exists
                                if (_.isEmpty(_exist)) {
                                    _newMetadata.metadata.push({
                                        tag: latest.metadata[i].tag,
                                        value: latest.metadata[i].value
                                    });
                                }

                            }
                        }

                        let _schemaCheck = v.validate(_newMetadata, metadataSchema);
                        if (_schemaCheck.valid) {
                            let params = {
                                TableName: ddbTable,
                                Item: _newMetadata
                            };

                            docClient.put(params, function(err, data) {
                                if (err) {
                                    console.log(err);
                                    return cb(err, null);
                                }

                                let _indexer = new Indexer();

                                _indexer.indexToSearch(_newMetadata.package_id, token,
                                    function(err, data) {
                                        if (err) {
                                            console.log(err);
                                            return cb(err, null);
                                        }

                                        return cb(null, _newMetadata);
                                    });
                            });
                        } else {
                            return cb({
                                error: {
                                    message: 'Invalid schema provided when attempting to create metadata.'
                                }
                            }, null);
                        }

                    });