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

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 return ( 

92 flask.jsonify( 

93 { 

94 "errors": api_response_error_list.errors, 

95 } 

96 ), 

97 400, 

98 ) 

99 

100 return flask.jsonify(response) 

101 

102 

103@login_required 

104def redirect_post_close_channel(snap_name): 

105 return flask.redirect( 

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

107 ) 

108 

109 

110@login_required 

111def post_close_channel(snap_name): 

112 data = flask.request.json 

113 

114 if not data: 

115 return flask.jsonify({}), 400 

116 

117 try: 

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

119 except StoreApiResponseErrorList as api_response_error_list: 

120 if api_response_error_list.status_code == 404: 

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

122 else: 

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

124 

125 try: 

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

127 except StoreApiResponseErrorList as api_response_error_list: 

128 if api_response_error_list.status_code == 404: 

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

130 else: 

131 response = { 

132 "errors": api_response_error_list.errors, 

133 "success": False, 

134 } 

135 return flask.jsonify(response), 400 

136 

137 response["success"] = True 

138 return flask.jsonify(response) 

139 

140 

141@login_required 

142def post_default_track(snap_name): 

143 data = flask.request.json 

144 

145 if not data: 

146 return flask.jsonify({}), 400 

147 

148 try: 

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

150 except StoreApiResponseErrorList as api_response_error_list: 

151 if api_response_error_list.status_code == 404: 

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

153 else: 

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

155 

156 try: 

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

158 except StoreApiResponseErrorList as api_response_error_list: 

159 if api_response_error_list.status_code == 404: 

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

161 else: 

162 response = { 

163 "errors": api_response_error_list.errors, 

164 "success": False, 

165 } 

166 return flask.jsonify(response), 400 

167 

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

169 

170 

171@login_required 

172def get_snap_revision_json(snap_name, revision): 

173 """ 

174 Return JSON object from the publisher API 

175 """ 

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

177 

178 return flask.jsonify(revision)