321 lines
8.6 KiB
JavaScript
321 lines
8.6 KiB
JavaScript
import ExpandableRecordArray from 'travis/utils/expandable-record-array';
|
|
import Model from 'travis/models/model';
|
|
import { durationFrom as durationFromHelper } from 'travis/utils/helpers';
|
|
import Build from 'travis/models/build';
|
|
import Config from 'travis/config/environment';
|
|
import DS from 'ember-data';
|
|
import Ember from 'ember';
|
|
|
|
var Repo;
|
|
|
|
if (Config.useV3API) {
|
|
Repo = Model.extend({
|
|
defaultBranch: DS.belongsTo('branch', {
|
|
async: false
|
|
}),
|
|
lastBuild: Ember.computed.oneWay('defaultBranch.lastBuild'),
|
|
lastBuildFinishedAt: Ember.computed.oneWay('lastBuild.finishedAt'),
|
|
lastBuildId: Ember.computed.oneWay('lastBuild.id'),
|
|
lastBuildState: Ember.computed.oneWay('lastBuild.state'),
|
|
lastBuildNumber: Ember.computed.oneWay('lastBuild.number'),
|
|
lastBuildStartedAt: Ember.computed.oneWay('lastBuild.startedAt'),
|
|
lastBuildDuration: Ember.computed.oneWay('lastBuild.duration')
|
|
});
|
|
} else {
|
|
Repo = Model.extend({
|
|
lastBuildNumber: DS.attr('number'),
|
|
lastBuildState: DS.attr(),
|
|
lastBuildStartedAt: DS.attr(),
|
|
lastBuildFinishedAt: DS.attr(),
|
|
_lastBuildDuration: DS.attr('number'),
|
|
lastBuildLanguage: DS.attr(),
|
|
lastBuildId: DS.attr('number'),
|
|
|
|
lastBuildHash: function() {
|
|
return {
|
|
id: this.get('lastBuildId'),
|
|
number: this.get('lastBuildNumber'),
|
|
repo: this
|
|
};
|
|
}.property('lastBuildId', 'lastBuildNumber'),
|
|
|
|
lastBuild: function() {
|
|
var id;
|
|
if (id = this.get('lastBuildId')) {
|
|
this.store.findRecord('build', id);
|
|
return this.store.recordForId('build', id);
|
|
}
|
|
}.property('lastBuildId'),
|
|
|
|
lastBuildDuration: function() {
|
|
var duration;
|
|
duration = this.get('_lastBuildDuration');
|
|
if (!duration) {
|
|
duration = durationFromHelper(this.get('lastBuildStartedAt'), this.get('lastBuildFinishedAt'));
|
|
}
|
|
return duration;
|
|
}.property('_lastBuildDuration', 'lastBuildStartedAt', 'lastBuildFinishedAt')
|
|
});
|
|
}
|
|
|
|
Repo.reopen({
|
|
ajax: Ember.inject.service(),
|
|
slug: DS.attr(),
|
|
description: DS.attr(),
|
|
"private": DS.attr('boolean'),
|
|
githubLanguage: DS.attr(),
|
|
active: DS.attr(),
|
|
|
|
withLastBuild() {
|
|
return this.filter(function(repo) {
|
|
return repo.get('lastBuildId');
|
|
});
|
|
},
|
|
|
|
sshKey: function() {
|
|
this.store.find('ssh_key', this.get('id'));
|
|
return this.store.recordForId('ssh_key', this.get('id'));
|
|
},
|
|
|
|
envVars: function() {
|
|
var id;
|
|
id = this.get('id');
|
|
return this.store.filter('env_var', {
|
|
repository_id: id
|
|
}, function(v) {
|
|
return v.get('repo.id') === id;
|
|
});
|
|
}.property(),
|
|
|
|
builds: function() {
|
|
var array, builds, id;
|
|
id = this.get('id');
|
|
builds = this.store.filter('build', {
|
|
event_type: ['push', 'api'],
|
|
repository_id: id
|
|
}, function(b) {
|
|
return b.get('repo.id') + '' === id + '' && (b.get('eventType') === 'push' || b.get('eventType') === 'api');
|
|
});
|
|
array = ExpandableRecordArray.create({
|
|
type: 'build',
|
|
content: Ember.A([])
|
|
});
|
|
array.load(builds);
|
|
array.observe(builds);
|
|
return array;
|
|
}.property(),
|
|
|
|
pullRequests: function() {
|
|
var array, builds, id;
|
|
id = this.get('id');
|
|
builds = this.store.filter('build', {
|
|
event_type: 'pull_request',
|
|
repository_id: id
|
|
}, function(b) {
|
|
return b.get('repo.id') + '' === id + '' && b.get('eventType') === 'pull_request';
|
|
});
|
|
array = ExpandableRecordArray.create({
|
|
type: 'build',
|
|
content: Ember.A([])
|
|
});
|
|
array.load(builds);
|
|
id = this.get('id');
|
|
array.observe(builds);
|
|
return array;
|
|
}.property(),
|
|
|
|
branches: function() {
|
|
var builds;
|
|
builds = this.store.query('build', {
|
|
repository_id: this.get('id'),
|
|
branches: true
|
|
});
|
|
builds.then(function() {
|
|
return builds.set('isLoaded', true);
|
|
});
|
|
return builds;
|
|
}.property(),
|
|
|
|
owner: function() {
|
|
return (this.get('slug') || '').split('/')[0];
|
|
}.property('slug'),
|
|
|
|
name: function() {
|
|
return (this.get('slug') || '').split('/')[1];
|
|
}.property('slug'),
|
|
|
|
sortOrderForLandingPage: function() {
|
|
var state;
|
|
state = this.get('lastBuildState');
|
|
if (state !== 'passed' && state !== 'failed') {
|
|
return 0;
|
|
} else {
|
|
return parseInt(this.get('lastBuildId'));
|
|
}
|
|
}.property('lastBuildId', 'lastBuildState'),
|
|
|
|
stats: function() {
|
|
if (this.get('slug')) {
|
|
return this.get('_stats') || $.get("https://api.github.com/repos/" + this.get('slug'), (data) => {
|
|
this.set('_stats', data);
|
|
return this.notifyPropertyChange('stats');
|
|
}) && {};
|
|
}
|
|
}.property('slug'),
|
|
|
|
updateTimes() {
|
|
var lastBuild;
|
|
if (Config.useV3API) {
|
|
if (lastBuild = this.get('lastBuild')) {
|
|
return lastBuild.updateTimes();
|
|
}
|
|
} else {
|
|
return this.notifyPropertyChange('lastBuildDuration');
|
|
}
|
|
},
|
|
|
|
regenerateKey(options) {
|
|
return this.get('ajax').ajax('/repos/' + this.get('id') + '/key', 'post', options);
|
|
},
|
|
|
|
fetchSettings() {
|
|
return this.get('ajax').ajax('/repos/' + this.get('id') + '/settings', 'get', {
|
|
forceAuth: true
|
|
}).then(function(data) {
|
|
return data['settings'];
|
|
});
|
|
},
|
|
|
|
saveSettings(settings) {
|
|
return this.get('ajax').ajax('/repos/' + this.get('id') + '/settings', 'patch', {
|
|
data: {
|
|
settings: settings
|
|
}
|
|
});
|
|
}
|
|
});
|
|
|
|
Repo.reopenClass({
|
|
recent() {
|
|
return this.find();
|
|
},
|
|
|
|
accessibleBy(store, reposIdsOrlogin) {
|
|
var login, promise, repos, reposIds;
|
|
if (Config.useV3API) {
|
|
reposIds = reposIdsOrlogin;
|
|
repos = store.filter('repo', function(repo) {
|
|
return reposIds.indexOf(parseInt(repo.get('id'))) !== -1;
|
|
});
|
|
promise = new Ember.RSVP.Promise(function(resolve, reject) {
|
|
return store.query('repo', {
|
|
'repository.active': 'true',
|
|
limit: 20
|
|
}).then(function() {
|
|
return resolve(repos);
|
|
}, function() {
|
|
return reject();
|
|
});
|
|
});
|
|
return promise;
|
|
} else {
|
|
login = reposIdsOrlogin;
|
|
return store.find('repo', {
|
|
member: login,
|
|
orderBy: 'name'
|
|
});
|
|
}
|
|
},
|
|
|
|
search(store, ajax, query) {
|
|
var promise, queryString, result;
|
|
if (Config.useV3API) {
|
|
queryString = $.param({
|
|
search: query,
|
|
orderBy: 'name',
|
|
limit: 5
|
|
});
|
|
promise = ajax.ajax("/repos?" + queryString, 'get');
|
|
result = Ember.ArrayProxy.create({
|
|
content: []
|
|
});
|
|
return promise.then(function(data, status, xhr) {
|
|
var promises;
|
|
promises = data.repos.map(function(repoData) {
|
|
return store.findRecord('repo', repoData.id).then(function(record) {
|
|
result.pushObject(record);
|
|
result.set('isLoaded', true);
|
|
return record;
|
|
});
|
|
});
|
|
return Ember.RSVP.allSettled(promises).then(function() {
|
|
return result;
|
|
});
|
|
});
|
|
} else {
|
|
return store.find('repo', {
|
|
search: query,
|
|
orderBy: 'name'
|
|
});
|
|
}
|
|
},
|
|
|
|
withLastBuild(store) {
|
|
var repos;
|
|
repos = store.filter('repo', {}, function(build) {
|
|
return build.get('lastBuildId');
|
|
});
|
|
repos.then(function() {
|
|
return repos.set('isLoaded', true);
|
|
});
|
|
return repos;
|
|
},
|
|
|
|
fetchBySlug(store, slug) {
|
|
var adapter, modelClass, promise, repos;
|
|
repos = store.peekAll('repo').filterBy('slug', slug);
|
|
if (repos.get('length') > 0) {
|
|
return repos.get('firstObject');
|
|
} else {
|
|
promise = null;
|
|
if (Config.useV3API) {
|
|
adapter = store.adapterFor('repo');
|
|
modelClass = store.modelFor('repo');
|
|
promise = adapter.findRecord(store, modelClass, slug).then(function(payload) {
|
|
var i, len, r, record, ref, repo, result, serializer;
|
|
serializer = store.serializerFor('repo');
|
|
modelClass = store.modelFor('repo');
|
|
result = serializer.normalizeResponse(store, modelClass, payload, null, 'findRecord');
|
|
repo = store.push({
|
|
data: result.data
|
|
});
|
|
ref = result.included;
|
|
for (i = 0, len = ref.length; i < len; i++) {
|
|
record = ref[i];
|
|
r = store.push({
|
|
data: record
|
|
});
|
|
}
|
|
return repo;
|
|
});
|
|
} else {
|
|
promise = store.find('repo', {
|
|
slug: slug
|
|
}).then(function(repos) {
|
|
return repos.get('firstObject') || (function() {
|
|
throw "no repos found";
|
|
})();
|
|
});
|
|
}
|
|
return promise["catch"](function() {
|
|
var error;
|
|
error = new Error('repo not found');
|
|
error.slug = slug;
|
|
throw error;
|
|
});
|
|
}
|
|
}
|
|
});
|
|
|
|
export default Repo;
|