· 5 years ago · Oct 23, 2020, 05:46 PM
1package helpers
2
3import (
4 "bgasoft.com/graphabc/backend/go-cli/prisma"
5 "bytes"
6 "context"
7 "encoding/json"
8 "errors"
9 "io/ioutil"
10 "fmt"
11 "net/http"
12 "strconv"
13 "time"
14
15)
16
17func GetOneRecord(modelCaption string,id string,client *prisma.Client, ctx context.Context) (map[string]interface{}, error) {
18
19 model, err := client.Model(
20 prisma.ModelWhereUniqueInput{
21 Caption: &modelCaption,
22 },
23 ).Exec(ctx)
24
25 if err != nil {
26 return nil, err
27 }
28 modelOperationReadOne, err := getModelOperation(model.ID, prisma.ModelOperationTypeReadOne,client, ctx)
29
30
31 if err != nil {
32 return nil, err
33 }
34 returnFields, err := getReturnedFields(model.ID,client, ctx)
35
36 if err != nil {
37 return nil, err
38 }
39
40 var query = "query($where: " + model.Name + "WhereUniqueInput!){ " + modelOperationReadOne.Name + "(where:$where){" + returnFields + "}}"
41 var variables = map[string]interface{}{
42 "where": map[string]interface{}{
43 "id": id,
44 },
45 }
46 res, err := client.GraphQL(ctx, query, variables)
47 if res!= nil{
48 var returnValue,_= res[modelOperationReadOne.Name].(map[string]interface{})
49 return returnValue, err
50 }
51 return nil, err
52}
53
54func GetManyRecords(modelCaption string,where map[string]interface{},client *prisma.Client, ctx context.Context) ([]interface{}, error) {
55 models, err := client.Model(prisma.ModelWhereUniqueInput{Caption: &modelCaption}).Exec(ctx)
56 if err != nil {
57 return nil, err
58 }
59
60 modelOperationReadMany, err := getModelOperation(models.ID, prisma.ModelOperationTypeReadMany,client, ctx)
61
62
63 if err != nil {
64 return nil, err
65 }
66 returnFields, err := getReturnedFields(models.ID,client, ctx)
67
68 if err != nil {
69 return nil, err
70 }
71
72 var query = "query($where: " + models.Name + "WhereInput){ " + modelOperationReadMany.Name + "(where:$where){" + returnFields + "}}"
73 var variables = map[string]interface{}{
74 "where": where,
75 }
76 res, err := client.GraphQL(ctx, query, variables)
77 if res != nil {
78 var returnValue,_= res[modelOperationReadMany.Name].([]interface{})
79 return returnValue, err
80 }
81 return nil, err
82}
83
84func CreateRecord(modelCaption string, data map[string]interface{},client *prisma.Client, ctx context.Context) (map[string]interface{}, error) {
85 models, err := client.Model(prisma.ModelWhereUniqueInput{Caption: &modelCaption}).Exec(ctx)
86 if err != nil {
87 return nil, err
88 }
89
90 modelOperationCreateInput, err := getModelOperation(models.ID, prisma.ModelOperationTypeCreate,client, ctx)
91
92 if err != nil {
93 return nil, err
94 }
95 returnFields, err := getReturnedFields(models.ID, client, ctx)
96
97 if err != nil {
98 return nil, err
99 }
100
101 var mutation = "mutation($data: " + models.Name + "CreateInput!){ " + modelOperationCreateInput.Name + "(data:$data){" + returnFields + "}}"
102 var variables = map[string]interface{}{
103 "data": data,
104 }
105 res, err := client.GraphQL(ctx, mutation, variables)
106 if res != nil {
107 var returnValue,_= res[modelOperationCreateInput.Name].(map[string]interface{})
108 return returnValue, err
109 }
110 return nil, err
111}
112
113func GetOneRecordRequest(modelCaption string,id string,client *prisma.Client, ctx context.Context ) (map[string]interface{}, error) {
114 model, err := client.Model(
115 prisma.ModelWhereUniqueInput{
116 Caption: &modelCaption,
117 },
118 ).Exec(ctx)
119
120 if err != nil {
121 return nil, err
122 }
123 modelOperationReadOne, err := getModelOperation(model.ID, prisma.ModelOperationTypeReadOne,client, ctx)
124
125
126 if err != nil {
127 return nil, err
128 }
129 returnFields, err := getReturnedFields(model.ID,client, ctx)
130
131 if err != nil {
132 return nil, err
133 }
134
135 var query = "query($where: " + model.Name + "WhereUniqueInput!){ " + modelOperationReadOne.Name + "(where:$where){" + returnFields + "}}"
136 var variables = map[string]interface{}{
137 "where": map[string]interface{}{
138 "id": id,
139 },
140 }
141 data := map[string]interface{}{
142 "alias": false,
143 "query": query,
144 "variables": variables,
145 }
146 response, err := sendRequest( model.ModelType, data, client,ctx)
147
148 return response, err
149}
150
151func GetManyRecordsRequest(modelCaption string, where map[string]interface{},client *prisma.Client, ctx context.Context) ([]interface{}, error) {
152 models, err := client.Model(prisma.ModelWhereUniqueInput{Caption: &modelCaption}).Exec(ctx)
153 if err != nil {
154 return nil, err
155 }
156
157 modelOperationReadMany, err := getModelOperation(models.ID, prisma.ModelOperationTypeReadMany,client, ctx)
158
159
160 if err != nil {
161 return nil, err
162 }
163 returnFields, err := getReturnedFields(models.ID,client, ctx)
164
165 if err != nil {
166 return nil, err
167 }
168
169 var query = "query($where: " + models.Name + "WhereInput){ " + modelOperationReadMany.Name + "(where:$where){" + returnFields + "}}"
170 var variables = map[string]interface{}{
171 "where": where,
172 }
173 data := map[string]interface{}{
174 "alias": false,
175 "query": query,
176 "variables": variables,
177 }
178 response, err := sendRequest( models.ModelType, data, client,ctx)
179 fmt.Println("This is the response message")
180 fmt.Println(response)
181 return nil, err
182
183}
184
185func UpdateRecord(modelCaption string,data map[string]interface{}, where map[string]interface{},client *prisma.Client, ctx context.Context) (map[string]interface{}, error) {
186 models, err := client.Model(prisma.ModelWhereUniqueInput{Caption: &modelCaption}).Exec(ctx)
187 if err != nil {
188 return nil, err
189 }
190 modelOperationUpdateInput, err := getModelOperation(models.ID, prisma.ModelOperationTypeUpdateOne,client, ctx)
191
192
193 if err != nil {
194 return nil, err
195 }
196 returnFields, err := getReturnedFields(models.ID,client, ctx)
197
198 if err != nil {
199 return nil, err
200 }
201 var mutation = "mutation($data: " + models.Name + "UpdateInput!,$where:" + models.Name + "WhereUniqueInput!){ " + modelOperationUpdateInput.Name + "(data:$data,where:$where){" + returnFields + "}}"
202 var variables = map[string]interface{}{
203 "data": data,
204 "where": where,
205 }
206 res, err := client.GraphQL(ctx, mutation, variables)
207 if res != nil {
208 var returnValue,_= res[modelOperationUpdateInput.Name].(map[string]interface{})
209 return returnValue, err
210 }
211 return nil, err
212}
213
214func DeleteRecord(modelCaption string, where map[string]interface{},client *prisma.Client, ctx context.Context) (map[string]interface{}, error) {
215 models, err := client.Model(prisma.ModelWhereUniqueInput{Caption: &modelCaption}).Exec(ctx)
216 if err != nil {
217 return nil, err
218 }
219 modelOperationDeleteInput, err := getModelOperation(models.ID, prisma.ModelOperationTypeDeleteOne,client, ctx)
220
221 if err != nil {
222 return nil, err
223 }
224 returnFields, err := getReturnedFields(models.ID,client, ctx)
225
226 if err != nil {
227 return nil, err
228 }
229 var mutation = "mutation($where: " + models.Name + "WhereUniqueInput!){ " + modelOperationDeleteInput.Name+ "(where:$where){" + returnFields + "}}"
230 var variables = map[string]interface{}{
231 "where": where,
232 }
233 res, err := client.GraphQL(ctx, mutation, variables)
234 if res != nil {
235 var returnValue,_= res[modelOperationDeleteInput.Name].(map[string]interface{})
236 return returnValue, err
237 }
238 return nil, err
239}
240
241func CreateRecordRequest(modelCaption string, data map[string]interface{},client *prisma.Client, ctx context.Context) (map[string]interface{}, error) {
242 models, err := client.Model(prisma.ModelWhereUniqueInput{Caption: &modelCaption}).Exec(ctx)
243 if err != nil {
244 return nil, err
245 }
246
247 modelOperationCreateInput, err := getModelOperation(models.ID, prisma.ModelOperationTypeCreate,client, ctx)
248
249 if err != nil {
250 return nil, err
251 }
252 returnFields, err := getReturnedFields(models.ID,client, ctx)
253
254 if err != nil {
255 return nil, err
256 }
257
258 var query = "mutation($data: " + models.Name + "CreateInput!){ " + modelOperationCreateInput.Name + "(data:$data){" + returnFields + "}}"
259 var variables = map[string]interface{}{
260 "data": data,
261 }
262 requestdata := map[string]interface{}{
263 "alias": false,
264 "query": query,
265 "variables": variables,
266 }
267 response, err := sendRequest( models.ModelType, requestdata, client,ctx)
268
269 return response, err
270}
271
272func UpdateRecordRequest(modelCaption string, data map[string]interface{}, where map[string]interface{},client *prisma.Client, ctx context.Context) (map[string]interface{}, error) {
273 models, err := client.Model(prisma.ModelWhereUniqueInput{Caption: &modelCaption}).Exec(ctx)
274 if err != nil {
275 return nil, err
276 }
277 modelOperationUpdateInput, err := getModelOperation(models.ID, prisma.ModelOperationTypeUpdateOne,client, ctx)
278
279 if err != nil {
280 return nil, err
281 }
282 returnFields, err := getReturnedFields(models.ID,client, ctx)
283
284 if err != nil {
285 return nil, err
286 }
287 var query = "mutation($data: " + models.Name + "UpdateInput!,$where:" + models.Name + "WhereUniqueInput!){ " + modelOperationUpdateInput.Name + "(data:$data,where:$where){" + returnFields + "}}"
288 var variables = map[string]interface{}{
289 "data": data,
290 "where": where,
291 }
292 dataReq := map[string]interface{}{
293 "alias": false,
294 "query": query,
295 "variables": variables,
296 }
297 response, err := sendRequest( models.ModelType, dataReq,client, ctx)
298
299 return response, err
300}
301
302func DeleteRecordRequest(modelCaption string, where map[string]interface{},client *prisma.Client, ctx context.Context) (map[string]interface{}, error) {
303 models, err := client.Model(prisma.ModelWhereUniqueInput{Caption: &modelCaption}).Exec(ctx)
304 if err != nil {
305 return nil, err
306 }
307 modelOperationDeleteInput, err := getModelOperation(models.ID, prisma.ModelOperationTypeDeleteOne,client, ctx)
308 fmt.Println(modelOperationDeleteInput.Name)
309
310 if err != nil {
311 return nil, err
312 }
313 returnFields, err := getReturnedFields(models.ID,client, ctx)
314
315 if err != nil {
316 return nil, err
317 }
318 var query = "mutation($where: " + models.Name + "WhereUniqueInput!){ " + modelOperationDeleteInput.Name + "(where:$where){" + returnFields + "}}"
319 var variables = map[string]interface{}{
320 "where": where,
321 }
322 fmt.Println(query)
323 fmt.Println(variables)
324 data := map[string]interface{}{
325 "alias": false,
326 "query": query,
327 "variables": variables,
328 }
329 response, err := sendRequest( models.ModelType, data,client, ctx)
330
331 return response, err
332}
333
334func GetModelConnectionRequest(modelCaption string,client *prisma.Client, ctx context.Context) (map[string]interface{}, error) {
335 model, err := client.Model(
336 prisma.ModelWhereUniqueInput{
337 Caption: &modelCaption,
338 },
339 ).Exec(ctx)
340
341 modelOperationConnectionInput, err := getModelOperation(model.ID, prisma.ModelOperationTypeConnection,client, ctx)
342 fmt.Println(modelOperationConnectionInput.Name)
343 if err != nil {
344 return nil, err
345 }
346 var query = "query{ " + modelOperationConnectionInput.Name + "{aggregate{count}}}"
347 var variables = map[string]interface{}{
348
349 }
350 data := map[string]interface{}{
351 "alias": false,
352 "query": query,
353 "variables": variables,
354 }
355 response, err := sendRequest( model.ModelType, data, client,ctx)
356
357 return response, err
358}
359
360func getBackedUrl(client *prisma.Client, ctx context.Context) (string, error) {
361 var param = "graphql_Url"
362 var apiUrl = ""
363 graphqlUrl, err := client.GraphAbcConfig(prisma.GraphAbcConfigWhereUniqueInput{
364 Name: ¶m,
365 }).Exec(ctx)
366 if err != nil {
367 return "", err
368 }
369 if (graphqlUrl.TypeAndValue["value"]) == nil {
370 return "", errors.New("Missing ConfigElement")
371 }
372 apiUrl = graphqlUrl.TypeAndValue["value"].(string)
373 param = "GRAPHQL_SERVER_PORT"
374 graphqlPort, err := client.GraphAbcConfig(prisma.GraphAbcConfigWhereUniqueInput{
375 Name: ¶m,
376 }).Exec(ctx)
377 if err != nil {
378 return "", err
379 }
380 if (graphqlPort.TypeAndValue["value"]) != nil {
381 interFaceToInt := int(graphqlPort.TypeAndValue["value"].(float64))
382 apiUrl += ":" + strconv.Itoa(interFaceToInt)
383
384 }
385 return apiUrl, nil
386}
387
388func getModelOperation(modelId string, modelOperationType prisma.ModelOperationType,client *prisma.Client, ctx context.Context) (prisma.ModelOperation, error) {
389 var modelOperation prisma.ModelOperation
390 modelOperations, err := client.ModelOperations(&prisma.ModelOperationsParams{Where: &prisma.ModelOperationWhereInput{Model: &prisma.ModelWhereInput{ID: &modelId}}}).Exec(ctx)
391 if err != nil {
392 return prisma.ModelOperation{}, err
393 }
394 for _, item := range modelOperations {
395
396 if item.ModelOperationType == modelOperationType {
397 modelOperation = item
398 break
399 }
400 }
401 return modelOperation, err
402}
403
404func getReturnedFields(modelId string,client *prisma.Client, ctx context.Context) (string, error) {
405 fields, err := client.FieldModels(&prisma.FieldModelsParams{Where: &prisma.FieldModelWhereInput{Model: &prisma.ModelWhereInput{ID: &modelId}}}).Exec(ctx)
406 if err != nil {
407 return "", err
408 }
409 var returnFields = ""
410 for _, field := range fields {
411 fieldModelRelationType, _ := client.FieldModel(prisma.FieldModelWhereUniqueInput{ID: &field.ID}).RelationType().Exec(ctx)
412 if fieldModelRelationType.Name != "Many" && fieldModelRelationType.Name != "One" {
413 returnFields += " " + field.Name
414
415 } else {
416 returnFields += " " + field.Name + "{id}"
417 }
418 }
419 return returnFields, err
420}
421
422func getApiKeys(userID string, sessionRoleID string,client *prisma.Client,ctx context.Context) (string, error) {
423 apiKeys, err := client.ApiKeys(&prisma.ApiKeysParams{
424 Where: &prisma.ApiKeyWhereInput{
425
426 User : &prisma.UserWhereInput{
427 ID :&userID,
428 },
429 },
430 }).Exec(ctx)
431
432
433 if err != nil {
434 return "", err
435 }
436 for _,apiKey := range apiKeys{
437 sessionRole, err := client.ApiKey(prisma.ApiKeyWhereUniqueInput{ID: &apiKey.ID}).SessionRole().Exec(ctx)
438 if sessionRole != nil && sessionRole.ID != sessionRoleID{
439 continue
440 }
441 if apiKey.ExpirationDate == nil{
442 return apiKey.Key, nil
443 }
444 expirationDate, err := time.Parse("2006-01-02T15:04:05.000Z", *apiKey.ExpirationDate)
445 if err != nil {
446 continue
447 }
448 if time.Now().Before(expirationDate) {
449 return apiKey.Key, nil
450 }
451 }
452
453 return "", errors.New("Not valid Api Key for this user")
454}
455
456func sendRequest( modelType prisma.ModelType, data map[string]interface{}, client *prisma.Client,ctx context.Context) (map[string]interface{}, error) {
457 var apiUrl, _ = getBackedUrl(client, ctx)
458 if modelType == prisma.ModelTypeUser {
459 apiUrl += "/prisma"
460
461 } else {
462 apiUrl += "/query"
463 }
464
465 jsonValue, _ := json.Marshal(data)
466 request, err := http.NewRequest("POST", apiUrl, bytes.NewBuffer(jsonValue))
467 request.Header.Set("Content-Type", "application/json")
468 apiKey, err := getApiKeys("ckev7ldr6007r0753y6ks20fo","graph123",client,ctx)
469 if err != nil || apiKey == ""{
470 return nil, errors.New("Not valid Api Key is found")
471
472 }
473
474 request.Header.Set("x-api-key",apiKey )
475 httpclient := &http.Client{}
476 response, err := httpclient.Do(request)
477 if err != nil {
478 return nil, err
479 }
480 body, err := ioutil.ReadAll(response.Body)
481 defer response.Body.Close()
482 if err != nil {
483 return nil, err
484 }
485 var decodedBody = map[string]interface{}{}
486 err = json.Unmarshal(body, &decodedBody)
487 return decodedBody, err
488}