nci-put-assignment-grades.c

   1 /*
   2  * Copyright (c) 2016-2019 S. Gilles <sgilles@math.umd.edu>
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software
   5  * for any purpose with or without fee is hereby granted, provided
   6  * that the above copyright notice and this permission notice appear
   7  * in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
  10  * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
  11  * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
  12  * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR
  13  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
  14  * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
  15  * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  16  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18 #include <errno.h>
  19 #include <locale.h>
  20 #include <stdint.h>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <unistd.h>
  25
  26 #include <curl/curl.h>
  27 #include <yajl_parse.h>
  28
  29 #include "macros.h"
  30 #include "util.h"
  31
  32 int
  33 prepare_csv_for_upload(char ***csv, size_t rows, size_t cols, long
  34                        long **course_ids, long long **assignment_ids)
  35 {
  36         size_t j = 0;
  37         long long course_id = 0;
  38         long long assignment_id = 0;
  39         char *past = 0;
  40         char *inv = 0;
  41         int sverr = 0;
  42         uint_fast8_t some_invalid = 0;
  43
  44         if (!(*course_ids = calloc((cols - 2), sizeof **course_ids))) {
  45                 sverr = errno;
  46                 perror(L("calloc"));
  47
  48                 return sverr;
  49         }
  50
  51         if (!(*assignment_ids = calloc((cols - 2), sizeof **assignment_ids))) {
  52                 sverr = errno;
  53                 perror(L("calloc"));
  54
  55                 return sverr;
  56         }
  57
  58         if (rows < 2) {
  59                 fprintf(stderr, "CSV has too few rows to contain data");
  60
  61                 return EINVAL;
  62         }
  63
  64         if (cols < 3) {
  65                 fprintf(stderr, "CSV has too few cols to contain data");
  66
  67                 return EINVAL;
  68         }
  69
  70         if (!csv[0][0] ||
  71             strcmp(csv[0][0], "Name") ||
  72             !csv[0][1] ||
  73             strcmp(csv[0][1], "ID")) {
  74                 fprintf(stderr, "CSV does not contain required header\n");
  75
  76                 return EINVAL;
  77         }
  78
  79         for (j = 1; j < rows; ++j) {
  80                 if (csv[j] &&
  81                     csv[j][1] &&
  82                     csv[j][1][0]) {
  83                         strtoll(csv[j][1], &inv, 0);
  84
  85                         if (inv &&
  86                             *inv) {
  87                                 fprintf(stderr,
  88                                         "Student ID in row %zu invalid\n", j);
  89                                 some_invalid = 1;
  90                         }
  91                 }
  92         }
  93
  94         if (some_invalid) {
  95                 return EINVAL;
  96         }
  97
  98         for (j = 2; j < cols; ++j) {
  99                 if (!csv[0][j]) {
 100                         fprintf(stderr,
 101                                 "CSV header cell %zu is blank - must contain "
 102                                 "<course-id>:assignment-id>\n", j + 1);
 103
 104                         return EINVAL;
 105                 }
 106
 107                 past = 0;
 108                 course_id = strtoll(csv[0][j], &past, 0);
 109
 110                 if (!past ||
 111                     !*past) {
 112                         fprintf(stderr, "CSV header cell %zu does not contain "
 113                                         "assignment-id - must contain "
 114                                         "<course-id>:assignment-id>\n", j + 1);
 115
 116                         return EINVAL;
 117                 }
 118
 119                 if (course_id <= 0) {
 120                         fprintf(stderr, "CSV header cell %zu references "
 121                                         "impossible course-id %lld\n", j + 1,
 122                                 course_id);
 123
 124                         return EINVAL;
 125                 }
 126
 127                 assignment_id = strtoll(past + 1, 0, 0);
 128
 129                 if (assignment_id <= 0) {
 130                         fprintf(stderr, "CSV header cell %zu references "
 131                                         "impossible assignment-id %lld\n", j +
 132                                 1, course_id);
 133
 134                         return EINVAL;
 135                 }
 136
 137                 (*course_ids)[j - 2] = course_id;
 138                 (*assignment_ids)[j - 2] = assignment_id;
 139         }
 140
 141         return 0;
 142 }
 143
 144 int
 145 main(void)
 146 {
 147         int ret = EINVAL;
 148         char *url_base = 0;
 149         char *auth_token = 0;
 150         size_t j = 0;
 151         size_t k = 0;
 152         size_t len = 0;
 153         char *built_uri = 0;
 154         char ***csv = 0;
 155         long long *course_ids = 0;
 156         long long *assignment_ids = 0;
 157         size_t rows = 0;
 158         size_t cols = 0;
 159         struct curl_httppost *post = 0;
 160
 161         setlocale(LC_ALL, "");
 162         UNUSED(built_uri);
 163         UNUSED(len);
 164         UNUSED(j);
 165         curl_global_init(CURL_GLOBAL_DEFAULT);
 166
 167         if (!(url_base = get_url_base())) {
 168                 ret = ENOENT;
 169
 170                 /* Error should have already been printed */
 171                 goto cleanup;
 172         }
 173
 174         if (!(auth_token = get_auth_token())) {
 175                 ret = ENOENT;
 176
 177                 /* Error should have already been printed */
 178                 goto cleanup;
 179         }
 180
 181         if ((ret = read_csv(stdin, &csv, &rows, &cols))) {
 182                 fprintf(stderr, "Error with CSV\n");
 183                 goto cleanup;
 184         }
 185
 186         if ((ret = prepare_csv_for_upload(csv, rows, cols, &course_ids,
 187                                           &assignment_ids))) {
 188                 /* Error should have already been printed */
 189                 goto cleanup;
 190         }
 191
 192         for (j = 2; j < cols; ++j) {
 193                 free(built_uri);
 194                 len = snprintf(0, 0, "%s/api/v1/courses/%lld/assignments/"
 195                                      "%lld/submissions/update_grades", url_base,
 196                                course_ids[j - 2],
 197                                assignment_ids[j - 2]);
 198
 199                 if (len + 1 < len) {
 200                         ret = errno = EOVERFLOW;
 201                         perror(L(""));
 202                         goto cleanup;
 203                 }
 204
 205                 if (!(built_uri = malloc(len + 1))) {
 206                         ret = errno;
 207                         perror(L("malloc"));
 208                         goto cleanup;
 209                 }
 210
 211                 sprintf(built_uri, "%s/api/v1/courses/%lld/assignments/"
 212                                    "%lld/submissions/update_grades", url_base,
 213                         course_ids[j - 2],
 214                         assignment_ids[j - 2]);
 215
 216                 if (!(post = make_update_grade_post(csv, j, rows))) {
 217                         /* XXX: pass back proper error code from make_update_grade_post() */
 218                         ret = ENOMEM;
 219                         goto cleanup;
 220                 }
 221
 222                 if ((ret = send_and_id_scan(built_uri, auth_token, post, "POST",
 223                                             0))) {
 224                         goto cleanup;
 225                 }
 226
 227                 curl_formfree(post);
 228                 post = 0;
 229         }
 230
 231         ret = 0;
 232 cleanup:
 233
 234         if (csv) {
 235                 for (j = 0; j < rows; ++j) {
 236                         if (csv[j]) {
 237                                 for (k = 0; k < cols; ++k) {
 238                                         free(csv[j][k]);
 239                                 }
 240
 241                                 free(csv[j]);
 242                         }
 243                 }
 244
 245                 free(csv);
 246         }
 247
 248         free(built_uri);
 249         curl_global_cleanup();
 250         free(url_base);
 251         free(auth_token);
 252         free(course_ids);
 253         free(assignment_ids);
 254
 255         return ret;
 256 }