Esempio n. 1
0
        public async Task <IActionResult> RegisterOperator([FromBody] OperatorRequest operatorRequest)
        {
            var result = await operatorProvider.PostOperatorAsync(operatorRequest);

            if (result.IsSuccess)
            {
                return(Ok(result));
            }

            return(BadRequest(result));
        }
Esempio n. 2
0
 public static void OperatorResolve(BookRequest b)
 {
     if (AdminBO.GetCountry().SendRequestToOperator)
     {
         HybridSet olist = OperatorBO.GetOperatorsForRequest(b);
         foreach (Operator o in olist)
         {
             OperatorRequest or = new OperatorRequest();
             or.Operator      = o;
             or.Request       = b;
             or.TimeOfRequest = DateTime.Now;
             BookRequestDAO.MakePersistent(or);
         }
     }
 }
Esempio n. 3
0
        public bool CreateRequest(IPlayer p)
        {
            if (!server.Config.AllowOperatorRequests)
            {
                return(false);
            }

            var result = reqs.All(r => r.Player != p);

            if (result)
            {
                var req = new OperatorRequest(p);
                reqs.Add(req);

                server.Logger.LogWarning($"New operator request from {p.Username}: {req.Code}");
            }

            return(result);
        }
Esempio n. 4
0
        public async Task <AuthenticationOperatorResult> PostOperatorAsync(OperatorRequest operatorRequest)
        {
            try
            {
                var existingUser = await userManager.FindByIdAsync(operatorRequest.RegistrationNumber);

                if (existingUser != null)
                {
                    var user = await dBContext.Users.FirstOrDefaultAsync(c => c.RegistrationNumber == operatorRequest.RegistrationNumber);

                    var result = mapper.Map <DB.User, Operator>(user);
                    return(new AuthenticationOperatorResult
                    {
                        IsSuccess = false,
                        Operator = result,
                        ErrorMessage = "Operador já cadastrado.",
                        Token = null
                    });
                }

                var newOperator = new DB.User
                {
                    Name               = operatorRequest.Name,
                    UserName           = operatorRequest.RegistrationNumber,
                    RegistrationNumber = operatorRequest.RegistrationNumber
                };

                var createdUser = await userManager.CreateAsync(newOperator, operatorRequest.Password);

                if (!createdUser.Succeeded)
                {
                    return(new AuthenticationOperatorResult
                    {
                        IsSuccess = false,
                        Operator = null,
                        ErrorMessage = createdUser.Errors.FirstOrDefault().Description,
                        Token = null
                    });
                }

                var createdOperator = await dBContext.Users.FirstOrDefaultAsync(c => c.RegistrationNumber == operatorRequest.RegistrationNumber);

                var resultOperator = mapper.Map <DB.User, Operator>(createdOperator);

                return(new AuthenticationOperatorResult
                {
                    IsSuccess = true,
                    Operator = resultOperator,
                    ErrorMessage = null,
                    Token = TokenGenerator(newOperator)
                });
            }
            catch (Exception ex)
            {
                logger?.LogError(ex.ToString());
                return(new AuthenticationOperatorResult
                {
                    IsSuccess = false,
                    Operator = null,
                    ErrorMessage = ex.Message,
                    Token = null
                });
            }
        }
 public static OperatorRequest MakePersistent(OperatorRequest or)
 {
     NHibernateHelper.GetCurrentSession().SaveOrUpdate(or);
     return(or);
 }