Exemplo n.º 1
0
        public async Task <OpResults <Value> > GetGramerciesByRecipientIdAsync(string recipientId)
        {
            OpResults <Value> results = new OpResults <Value>();

            try
            {
                Value result = await _faunaClient.Query(
                    Map(
                        Paginate(
                            Match(
                                Index("user_gramercy"),
                                recipientId,
                                (int)Constants.Enums.GramercyStatus.Approved
                                )
                            ),
                        Lambda(
                            "gramercy",
                            Get(
                                Var("gramercy")
                                )
                            )
                        )
                    );

                Value[] data = result.At("data").To <Value[]>().Value;
                results.Results = data.ToList();
            }
            catch (Exception ex)
            {
                results.FromException(ex);
            }

            return(results);
        }
Exemplo n.º 2
0
        public async Task <OpResults <Value> > GetPendingGramerciesAsync()
        {
            OpResults <Value> results = new OpResults <Value>();

            try
            {
                Value pendingResults = await _faunaClient.Query(
                    Map(
                        Paginate(
                            Match(
                                Index("status_gramercy"),
                                (int)Constants.Enums.GramercyStatus.Pending
                                )
                            ),
                        Lambda(
                            "gramercy",
                            Get(
                                Var("gramercy")
                                )
                            )
                        )
                    );

                Value heldResults = await _faunaClient.Query(
                    Map(
                        Paginate(
                            Match(
                                Index("status_gramercy"),
                                (int)Constants.Enums.GramercyStatus.Hold
                                )
                            ),
                        Lambda(
                            "gramercy",
                            Get(
                                Var("gramercy")
                                )
                            )
                        )
                    );

                List <Value> data = pendingResults.At("data").To <Value[]>().Value.ToList();
                data.AddRange(heldResults.At("data").To <Value[]>().Value.ToList());

                results.Results = data;
            }
            catch (Exception ex)
            {
                results.FromException(ex);
            }

            return(results);
        }
Exemplo n.º 3
0
        public async Task <OpResults <Gramercy> > GetGramerciesByRecipientIdAsync(string recipientId)
        {
            OpResults <Gramercy> results = new OpResults <Gramercy>();

            try
            {
                FaunaContext      faunaContext        = new FaunaContext();
                OpResults <Value> userGramercyResults = await faunaContext.GetGramerciesByRecipientIdAsync(recipientId);

                if (userGramercyResults.Code != Constants.Enums.OperationResultCode.Success)
                {
                    results.CopyFrom(userGramercyResults);
                    return(results);
                }

                results.Results = userGramercyResults.Results.Select(s => s.ToGramercy()).ToList();
            }
            catch (Exception ex)
            {
                results.FromException(ex);
            }

            return(results);
        }
Exemplo n.º 4
0
        public async Task <OpResults <Gramercy> > GetPendingGramerciesAsync()
        {
            OpResults <Gramercy> results = new OpResults <Gramercy>();

            try
            {
                FaunaContext      faunaContext           = new FaunaContext();
                OpResults <Value> pendingGramercyResults = await faunaContext.GetPendingGramerciesAsync();

                if (pendingGramercyResults.Code != Constants.Enums.OperationResultCode.Success)
                {
                    results.CopyFrom(pendingGramercyResults);
                    return(results);
                }

                results.Results = pendingGramercyResults.Results.Select(s => s.ToGramercy()).ToList();
            }
            catch (Exception ex)
            {
                results.FromException(ex);
            }

            return(results);
        }