Coverage for webapp/publisher/snaps/release_views.py: 84%

1# Packages 

2import flask 

3from canonicalwebteam.store_api.dashboard import Dashboard 

4from canonicalwebteam.exceptions import StoreApiResponseErrorList 

5 

6# Local 

7from webapp.helpers import api_publisher_session 

8from webapp.decorators import login_required 

9 

10dashboard = Dashboard(api_publisher_session) 

11 

12 

13@login_required 

14def redirect_get_release_history(snap_name): 

15 return flask.redirect( 

16 flask.url_for(".get_release_history", snap_name=snap_name) 

17 ) 

18 

19 

20@login_required 

21def get_release_history_data(snap_name): 

22 release_history = dashboard.snap_release_history(flask.session, snap_name) 

23 

24 channel_map = dashboard.snap_channel_map(flask.session, snap_name) 

25 

26 snap = channel_map.get("snap", {}) 

27 

28 context = { 

29 "snap_name": snap_name, 

30 "snap_title": snap.get("title"), 

31 "publisher_name": snap.get("publisher", {}).get("display-name", {}), 

32 "release_history": release_history, 

33 "private": snap.get("private"), 

34 "default_track": ( 

35 snap.get("default-track") 

36 if snap.get("default-track") is not None 

37 else "latest" 

38 ), 

39 "channel_map": channel_map.get("channel-map"), 

40 "tracks": snap.get("tracks"), 

41 } 

42 

43 return flask.jsonify({"success": True, "data": context}) 

44 

45 

46@login_required 

47def get_releases(snap_name): 

48 # If this fails, the page will 404 

49 dashboard.get_snap_info(flask.session, snap_name) 

50 return flask.render_template("store/publisher.html") 

51 

52 

53@login_required 

54def redirect_post_release(snap_name): 

55 return flask.redirect( 

56 flask.url_for(".post_release", snap_name=snap_name), 307 

57 ) 

58 

59 

60@login_required 

61def get_release_history_json(snap_name): 

62 page = flask.request.args.get("page", default=1, type=int) 

63 

64 try: 

65 release_history = dashboard.snap_release_history( 

66 flask.session, snap_name, page 

67 ) 

68 except StoreApiResponseErrorList as api_response_error_list: 

69 if api_response_error_list.status_code == 404: 

70 return flask.abort(404, "No snap named {}".format(snap_name)) 

71 else: 

72 return flask.jsonify(api_response_error_list.errors), 400 

73 

74 return flask.jsonify(release_history) 

75 

76 

77@login_required 

78def post_release(snap_name): 

79 data = flask.request.json 

80 

81 if not data: 

82 response = {"errors": ["No changes were submitted"]} 

83 return flask.jsonify(response), 400 

84 

85 try: 

86 response = dashboard.post_snap_release(flask.session, data) 

87 except StoreApiResponseErrorList as api_response_error_list: 

88 if api_response_error_list.status_code == 404: 

89 return flask.abort(404, "No snap named {}".format(snap_name)) 

90 else: 

91 response = { 

92 "errors": api_response_error_list, 

93 } 

94 return flask.jsonify(response), 400 

95 

96 return flask.jsonify(response) 

97 

98 

99@login_required 

100def redirect_post_close_channel(snap_name): 

101 return flask.redirect( 

102 flask.url_for(".post_close_channel", snap_name=snap_name), 307 

103 ) 

104 

105 

106@login_required 

107def post_close_channel(snap_name): 

108 data = flask.request.json 

109 

110 if not data: 

111 return flask.jsonify({}), 400 

112 

113 try: 

114 snap_id = dashboard.get_snap_id(flask.session, snap_name) 

115 except StoreApiResponseErrorList as api_response_error_list: 

116 if api_response_error_list.status_code == 404: 

117 return flask.abort(404, "No snap named {}".format(snap_name)) 

118 else: 

119 return flask.jsonify(api_response_error_list.errors), 400 

120 

121 try: 

122 response = dashboard.post_close_channel(flask.session, snap_id, data) 

123 except StoreApiResponseErrorList as api_response_error_list: 

124 if api_response_error_list.status_code == 404: 

125 return flask.abort(404, "No snap named {}".format(snap_name)) 

126 else: 

127 response = { 

128 "errors": api_response_error_list.errors, 

129 "success": False, 

130 } 

131 return flask.jsonify(response), 400 

132 

133 response["success"] = True 

134 return flask.jsonify(response) 

135 

136 

137@login_required 

138def post_default_track(snap_name): 

139 data = flask.request.json 

140 

141 if not data: 

142 return flask.jsonify({}), 400 

143 

144 try: 

145 snap_id = dashboard.get_snap_id(flask.session, snap_name) 

146 except StoreApiResponseErrorList as api_response_error_list: 

147 if api_response_error_list.status_code == 404: 

148 return flask.abort(404, "No snap named {}".format(snap_name)) 

149 else: 

150 return flask.jsonify(api_response_error_list.errors), 400 

151 

152 try: 

153 dashboard.snap_metadata(flask.session, snap_id, data) 

154 except StoreApiResponseErrorList as api_response_error_list: 

155 if api_response_error_list.status_code == 404: 

156 return flask.abort(404, "No snap named {}".format(snap_name)) 

157 else: 

158 response = { 

159 "errors": api_response_error_list.errors, 

160 "success": False, 

161 } 

162 return flask.jsonify(response), 400 

163 

164 return flask.jsonify({"success": True}) 

165 

166 

167@login_required 

168def get_snap_revision_json(snap_name, revision): 

169 """ 

170 Return JSON object from the publisher API 

171 """ 

172 revision = dashboard.get_snap_revision(flask.session, snap_name, revision) 

173 

174 return flask.jsonify(revision)