1import logging 

2 

3from actstream import actions 

4from actstream.models import followers 

5from django.contrib.auth.decorators import login_required 

6from django.http import Http404, HttpResponse, HttpResponseForbidden 

7from django.shortcuts import get_object_or_404, redirect, render 

8from django.utils.translation import gettext as _ 

9from django_sendfile import sendfile 

10 

11from discuss_data.core.decorators import dd_tou_accepted 

12from discuss_data.core.helpers import check_perms, is_curator_or_check_perms_for_ds 

13from discuss_data.core.views import core_search_view 

14from discuss_data.dddatasets.models import ( 

15 Category, 

16 DataFile, 

17 DataSet, 

18 DataSetAccessRequest, 

19 DataSetManagementObject, 

20) 

21from discuss_data.dddatasets.utils import check_published 

22 

23logger = logging.getLogger(__name__) 

24 

25 

26# ************ 

27# public views 

28# ************ 

29 

30 

31def search(request): 

32 return core_search_view(request, "dataset_index", 10) 

33 

34 

35# unused? 

36def listing(request): 

37 dsmos = DataSetManagementObject.objects.select_related("main_published_ds") 

38 datasets = list() 

39 for dsmo in dsmos: 

40 if dsmo.main_published_ds: 

41 datasets.append(dsmo.main_published_ds) 

42 

43 return render( 

44 request, 

45 "dddatasets/listing.html", 

46 {"datasets": datasets, "pagetitle": _("Datasets")}, 

47 ) 

48 

49 

50def category_list(request): 

51 categories = Category.objects.all() 

52 return render( 

53 request, 

54 "dddatasets/category_list.html", 

55 {"categories": categories, "pagetitle": _("Categories")}, 

56 ) 

57 

58 

59def category_page(request, slug): 

60 logger.debug("category slug: {}".format(slug)) 

61 category = Category.objects.get(slug=slug) 

62 return core_search_view(request, "dataset_index", 10, category=category) 

63 

64 

65def detail(request, uuid): 

66 ds = check_published(uuid) 

67 return render(request, "dddatasets/detail.html", {"ds": ds, "type": "description"}) 

68 

69 

70def metadata(request, uuid): 

71 ds = check_published(uuid) 

72 return render( 

73 request, 

74 "dddatasets/metadata.html", 

75 {"ds": ds, "updated": True, "type": "metadata"}, 

76 ) 

77 

78 

79def access(request, uuid): 

80 ds = check_published(uuid) 

81 return render( 

82 request, 

83 "dddatasets/access.html", 

84 {"ds": ds, "updated": True, "type": "access"}, 

85 ) 

86 

87 

88def files(request, uuid): 

89 ds = check_published(uuid) 

90 datafiles = list() 

91 for datafile in ds.get_datafiles(): 

92 if datafile.data_file_type in ( 

93 datafile.FILE_TYPE_DATA, 

94 datafile.FILE_TYPE_CONVERTED, 

95 ): 

96 # if dataset is RA check permissions 

97 if ( 

98 ds.data_access != ds.RESTRICTED_ACCESS 

99 or is_curator_or_check_perms_for_ds( 

100 "ra_view_dataset", request.user, datafile.dataset 

101 ) 

102 ): 

103 datafiles.append( 

104 (datafile, datafile.file.size, datafile.get_file_format()) 

105 ) 

106 else: 

107 datafiles.append(("RA", datafile.file.size, datafile.get_file_format())) 

108 else: 

109 datafiles.append((datafile, datafile.file.size, datafile.get_file_format())) 

110 

111 return render( 

112 request, 

113 "dddatasets/files.html", 

114 {"ds": ds, "updated": True, "type": "files", "datafiles": datafiles}, 

115 ) 

116 

117 

118def files_pdf(request, uuid): 

119 ds = get_object_or_404(DataSet, uuid=uuid) 

120 

121 try: 

122 pdf_file = DataFile.objects.filter(dataset=ds, data_file_type="PDF")[0] 

123 except DataFile.DoesNotExist as e: 

124 raise Http404 from e 

125 

126 return download(request, pdf_file) 

127 

128 

129def files_zip(request, uuid): 

130 ds = get_object_or_404(DataSet, uuid=uuid) 

131 try: 

132 datafile = DataFile.objects.get(dataset=ds, data_file_type="ZIP") 

133 except DataFile.DoesNotExist as e: 

134 raise Http404 from e 

135 

136 if ds.data_access != ds.RESTRICTED_ACCESS or is_curator_or_check_perms_for_ds( 

137 "ra_view_dataset", request.user, datafile.dataset 

138 ): 

139 return download(request, datafile) 

140 

141 return HttpResponseForbidden() 

142 

143 

144def files_download(request, uuid, df_uuid): 

145 # REFACTOR!!!!1! 

146 ds = get_object_or_404(DataSet, uuid=uuid) 

147 datafile = DataFile.objects.get(uuid=df_uuid, dataset=ds) 

148 logger.info("datafile.file.path: %s", datafile.file.path, exc_info=1) 

149 logger.info( 

150 "datafile.get_download_file_name(): %s", datafile.get_download_file_name() 

151 ) 

152 # check permissions for the dataset if it is of filetype DATA or CONVERTED 

153 if datafile.data_file_type in ( 

154 datafile.FILE_TYPE_DATA, 

155 datafile.FILE_TYPE_CONVERTED, 

156 ): 

157 # if dataset is RA check permissions 

158 if ds.data_access != ds.RESTRICTED_ACCESS or is_curator_or_check_perms_for_ds( 

159 "ra_view_dataset", request.user, datafile.dataset 

160 ): 

161 return download(request, datafile) 

162 

163 return HttpResponseForbidden() 

164 

165 return download(request, datafile) 

166 

167 

168def download(request, datafile): 

169 """sendfile download wrapper 

170 """ 

171 return sendfile( 

172 request, 

173 datafile.file.path, 

174 attachment=True, 

175 attachment_filename=datafile.get_download_file_name(), 

176 ) 

177 

178 

179def publications(request, uuid): 

180 ds = check_published(uuid) 

181 return render( 

182 request, "dddatasets/publications.html", {"ds": ds, "type": "publications"}, 

183 ) 

184 

185 

186def versions(request, uuid): 

187 ds = check_published(uuid) 

188 published_versions = ds.get_published_versions() 

189 return render( 

190 request, 

191 # 'dataset/versions/versions_tab.html', 

192 "dddatasets/versions.html", 

193 {"ds": ds, "type": "versions", "versions": published_versions}, 

194 ) 

195 

196 

197def discuss(request, uuid): 

198 ds = check_published(uuid) 

199 return render(request, "dddatasets/discuss.html", {"ds": ds, "type": "discuss"}) 

200 

201 

202# ************ 

203# views that require log-in 

204# ************ 

205@login_required 

206@dd_tou_accepted 

207def follow(request, uuid): 

208 # redirect if no intercooler request 

209 if not request.is_intercooler(): 

210 return redirect("dddatasets:search") 

211 try: 

212 dataset = DataSet.objects.get(uuid=uuid) 

213 except Exception: 

214 raise Http404("Page not found.") 

215 

216 if request.user in followers(dataset): 

217 actions.unfollow(request.user, dataset) 

218 else: 

219 actions.follow(request.user, dataset) 

220 return render( 

221 request, 

222 "ddusers/_follow_button.html", 

223 { 

224 "object": dataset, 

225 "follow_url": "dddatasets:follow", 

226 "follow_text": "Follow this Dataset", 

227 }, 

228 ) 

229 

230 

231@login_required 

232@dd_tou_accepted 

233def access_request(request, uuid): 

234 ds = check_published(uuid) 

235 # check restricted access view permissions for the dataset 

236 if check_perms("ra_view_dataset", request.user, ds): 

237 # user has already access 

238 return HttpResponse( 

239 '<button class="btn btn-success" disabled>{}</button>'.format( 

240 _("You have access to this Dataset") 

241 ) 

242 ) 

243 

244 if request.method == "POST": 

245 ds_access_request = DataSetAccessRequest(dataset=ds, user=request.user) 

246 ds_access_request.save() 

247 

248 return HttpResponse( 

249 '<button class="btn btn-secondary" disabled>{}</button>'.format( 

250 ds_access_request 

251 ) 

252 ) 

253 else: 

254 ds_access_request = ds.get_access_request(request.user) 

255 if ds_access_request: 

256 return HttpResponse( 

257 '<button class="btn btn-secondary" disabled>{}</button>'.format( 

258 ds_access_request 

259 ) 

260 ) 

261 return render( 

262 request, 

263 "dddatasets/_access_request.html", 

264 { 

265 "add_url": "dddatasets:access_request", 

266 "object": ds, 

267 "btn_text": "Request Access", 

268 }, 

269 )