Example #1
0
        public async Task LogAsync(CommandContext context, DiscordChannel channel)
        {
            var config = await _databaseContext.GuildConfigs
                         .Where(e => e.GuildId == context.Guild.Id)
                         .FirstOrDefaultAsync();

            if (config == null)
            {
                config = new GuildConfig
                {
                    Prefix  = ".",
                    GuildId = context.Guild.Id
                };
                await _databaseContext.AddAsync(config);
            }

            if (channel == null)
            {
                config.LogChannel = null;
                await context.RespondAsync("Log channel has been cleared.");
            }
            else
            {
                config.LogChannel = channel.Id;
                await context.RespondAsync($"Log channel set to {channel.Mention}");
            }

            await _databaseContext.SaveChangesAsync();
        }
Example #2
0
        public virtual async Task <T> InsertAsync(T entity)
        {
            var result = await Context.AddAsync(entity);

            await Context.SaveChangesAsync();

            return(result.Entity);
        }
Example #3
0
        public async Task <IComment> addComment(IComment comment)
        {
            comment.date = DateTime.Now;
            await _usersRepository.AddAsync(comment);

            await _usersRepository.SaveChangesAsync();

            return(comment);
        }
Example #4
0
        public async Task <IActionResult> LoginResult()
        {
            var result = await HttpContext.AuthenticateAsync(CookieAuthenticationDefaults.AuthenticationScheme);

            if (result.Succeeded)
            {
                string email = result.Principal.Identities.First().Claims
                               .Where(claim => claim.Type == "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/emailaddress")
                               .Select(claim => claim.Value).FirstOrDefault();

                User user = _context.Users.FirstOrDefault(u => u.Email == email);

                if (user is null)
                {
                    user = new User
                    {
                        UserId      = email.Split('@')[0],
                        Email       = email,
                        DateCreated = DateTime.Now,
                        Token       = GenerateToken()
                    };

                    await _context.AddAsync(user);

                    await _context.SaveChangesAsync();
                }

                return(Redirect("/"));
            }

            return(RedirectToAction(nameof(Login)));
        }
        public async Task <Churrasco> Add(ChurrascoAddDto churrascoAddDto)
        {
            Churrasco churrasco = new Churrasco
            {
                DataChurras = churrascoAddDto.DataChurras,
                Motivo      = churrascoAddDto.Motivo,
                Observacoes = churrascoAddDto.Observacoes
            };

            if (churrascoAddDto.ValorSugerido <= 0)
            {
                churrasco.ValorSugerido          = decimal.Parse(_configuration["ValorSugerido"]);
                churrasco.ValorSugeridoSemBebida = churrasco.ValorSugerido - 10;
            }
            else if (churrascoAddDto.ValorSugerido < 10)
            {
                churrasco.ValorSugeridoSemBebida = 0;
            }
            else
            {
                churrasco.ValorSugeridoSemBebida = churrascoAddDto.ValorSugerido - 10;
            }

            await _context.AddAsync(churrasco);

            return(churrasco);
        }
        public async Task <BasicResponseInfo> Handle(RegisterUserRequest request, CancellationToken cancellationToken)
        {
            if (string.IsNullOrEmpty(request.Username) || string.IsNullOrEmpty(request.Password))
            {
                return(new BasicResponseInfo(false, HttpStatusCode.BadRequest, "Required 'Username' and 'Password'."));
            }

            var isUserExist = _databaseContext.SystemUsers.Any(x => x.Username == request.Username);

            if (isUserExist)
            {
                return(new BasicResponseInfo(false, HttpStatusCode.Conflict, "User already exists!"));
            }

            var userSalt = _saltGeneratorUtility.Generate();

            var password = _userPasswordUtility.HashPassword(request.Password, userSalt);

            var newUser = new SystemUser()
            {
                Username = request.Username,
                Salt     = userSalt,
                Password = password
            };

            await _databaseContext.AddAsync(newUser).ConfigureAwait(false);

            await _databaseContext.SaveChangesAsync().ConfigureAwait(false);

            return(new BasicResponseInfo(true, HttpStatusCode.Created, "User added."));
        }
Example #7
0
        public async Task <long> CreateComment(CommentObject comObj, long postId)
        {
            var post = await _database.Posts.FirstOrDefaultAsync(i => i.Id == postId);

            if (post == null)
            {
                return(-1);
            }

            var comment = new Comment()
            {
                Author     = comObj.Author,
                Text       = comObj.Text,
                CreateDate = DateTime.Now,
                PostId     = postId,
                Post       = post
            };

            post.CommentCount++;
            await _database.AddAsync(comment);

            await _database.SaveChangesAsync();

            return(comment.Id);
        }
Example #8
0
        public async Task <ActionResult> Create(AnimeSeries series)
        {
            if (!ModelState.IsValid)
            {
                return(NotFound());
            }

            AnimeSeries findExisting = await _context.AnimeSeries.
                                       Include(p => p.Picture).
                                       Include(se => se.SeasonsEpisodes).
                                       FirstOrDefaultAsync(s =>
                                                           s.EnglishTitle.Equals(series.EnglishTitle, StringComparison.OrdinalIgnoreCase) ||
                                                           s.JapaneseName.Equals(series.JapaneseName, StringComparison.OrdinalIgnoreCase
                                                                                 ));

            if (findExisting == null)
            {
                var asyncAdded = _context.AddAsync(new AnimeSeries().ToModel(series));
                if (asyncAdded.IsCompletedSuccessfully)
                {
                    await _context.SaveChangesAsync();

                    return(Ok(new BasicResponse {
                        Success = true
                    }));
                }
            }
            return(Ok(new BasicResponse {
                Success = false, Error = "Series already exists"
            }));
        }
        public async Task <ShoppingCart> GetShoppingCart()
        {
            var loggedUser = _httpContextAccessor.HttpContext.User;
            var userId     = _userManager.GetUserId(loggedUser);

            var applicationUser = await _context.Users
                                  .Include(sc => sc.ShoppingCart)
                                  .ThenInclude(i => i.Items)
                                  .ThenInclude(m => m.MobilePhoneRef)
                                  .FirstOrDefaultAsync(u => u.Id == userId);

            if (applicationUser == null)
            {
                return(null);
            }

            if (applicationUser.ShoppingCart == null)
            {
                var sc = new ShoppingCart()
                {
                    Id = Guid.NewGuid().ToString()
                };
                applicationUser.ShoppingCart   = sc;
                applicationUser.ShoppingCardId = sc.Id;
                _context.Update(applicationUser);
                await _context.AddAsync(sc);

                await _context.SaveChangesAsync();
            }

            return(applicationUser.ShoppingCart);
        }
        public async Task <IActionResult> PayU_Redirect(string amount)
        {
            if (!string.IsNullOrEmpty(amount))
            {
                var results = await PaymentService.CreateOrder(amount);

                // retry if no response
                if (string.IsNullOrEmpty(results))
                {
                    await PaymentService.GetAccessToken();

                    results = await PaymentService.CreateOrder(amount);
                }

                // if still no response
                if (string.IsNullOrEmpty(results))
                {
                    return(RedirectToAction("Error", "Payment"));
                }

                var separatedResults = results.Split(";");
                await _context.AddAsync(new Models.OrderModel
                {
                    Id          = separatedResults[1],
                    UserModelId = AuthService.GetJWTAudience(HttpContext.Session.GetString("TOKEN"))
                });

                await _context.SaveChangesAsync();

                return(Redirect(separatedResults[0]));
            }

            return(RedirectToAction("Index", "Home"));
        }
Example #11
0
        public async Task AddAsync(TEntity entity)
        {
            using var context = new DatabaseContext();
            await context.AddAsync(entity);

            await context.SaveChangesAsync();
        }
Example #12
0
        public async Task <ChoiceGetData> PostAsync(ChoicePostData data)
        {
            using var connection = authService.Connection;

            var optionsArray = data.Options.Split(",").Select(o => o.Trim()).ToArray();

            if (optionsArray.Length < 2)
            {
                throw new Exception("At least 2 options are required.");
            }
            string optionsString = string.Join(",", optionsArray);

            var entity = new ChoiceEntity()
            {
                Name    = data.Name.Trim(),
                Options = optionsString,
                UserId  = authService.UserId
            };

            var context = new DatabaseContext(connection);
            await context.AddAsync(entity);

            await context.SaveChangesAsync();

            await connection.CloseAsync();

            return(CreateGetDataFromEntity(entity));
        }
Example #13
0
        public async Task CreateWebhooks(Project project)
        {
            var webhooks = new List <Webhook>();
            var actions  = new[] { "Push", "Delete" };

            foreach (var action in actions)
            {
                var result = await _githubService.CreateWebhook(project, action);

                if (result.ErrorMessage != null)
                {
                    _toastService.ShowToast(result.ErrorMessage, ToastLevel.Error);
                    return;
                }

                var webhook = new Webhook
                {
                    Id        = result.Response.id,
                    Name      = result.Response.name,
                    Type      = result.Response.type,
                    Url       = result.Response.config.url,
                    ProjectId = project.Id,
                };
                webhooks.Add(webhook);
            }

            foreach (var wh in webhooks)
            {
                await _databaseContext.AddAsync(wh);
            }

            await _databaseContext.SaveChangesAsync();
        }
Example #14
0
        public async Task <string> AddOrder(ShoppingCartVM shoppingCartVM, string userId, int shippingAddressId)
        {
            if (shoppingCartVM.Items.Count == 0)
            {
                return("-1");
            }
            var order = new Order()
            {
                ApplicationUserId = userId,
                Id = Guid.NewGuid().ToString(),
                ShippingAddressId = shippingAddressId
            };
            await _context.AddAsync(order);

            await _context.SaveChangesAsync();

            foreach (var item in shoppingCartVM.Items)
            {
                var orderItem = new OrderMobilePhone()
                {
                    OrderRef       = order,
                    OrderId        = order.Id,
                    MobilePhoneId  = item.MobilePhoneId,
                    MobilePhoneRef = item.MobilePhoneRef,
                    Quantity       = item.Quantity
                };
                order.Items.Add(orderItem);
            }
            _context.Update(order);
            await _context.SaveChangesAsync();

            return(order.Id);
        }
Example #15
0
        public static async Task <byte[]> EncryptPassword(string password, string userId, DatabaseContext _context)
        {
            using var deriveBytes = new Rfc2898DeriveBytes(password, PBKDF2[0], PBKDF2[1]);

            var salt = new SaltModel
            {
                UserModelId = userId,
                Value       = deriveBytes.Salt
            };
            var key = deriveBytes.GetBytes(PBKDF2[0]);

            var userSalt = await _context.Salts.Where(s => s.UserModelId == userId).FirstOrDefaultAsync();

            if (userSalt != null)
            {
                userSalt.Value = salt.Value;
                _context.Entry(userSalt).State = EntityState.Modified;
            }
            else
            {
                await _context.AddAsync(salt);
            }

            return(key);
        }
        public async Task <BasicResponseInfo> Handle(CreateMailingGroupRequest request, CancellationToken cancellationToken)
        {
            if (string.IsNullOrEmpty(request.Name))
            {
                return(new BasicResponseInfo(false,
                                             HttpStatusCode.BadRequest,
                                             $"Mailing group name is undefined."));
            }

            var existingMailingGroup = _databaseContext
                                       .MailingGroups
                                       .Where(x => x.SystemUserId == request.UserId)
                                       .Any(x => x.Name == request.Name);

            if (existingMailingGroup)
            {
                return(new BasicResponseInfo(false,
                                             HttpStatusCode.Conflict,
                                             $"The operation has been rolled back. Mailing group name '{request.Name}' has already added."));
            }

            var newMailingGroup = new MailingGroup()
            {
                Name         = request.Name,
                SystemUserId = request.UserId
            };

            await _databaseContext.AddAsync(newMailingGroup).ConfigureAwait(false);

            await _databaseContext.SaveChangesAsync().ConfigureAwait(false);

            return(new BasicResponseInfo(true,
                                         HttpStatusCode.Created,
                                         $"Success. Mailing group with name '{request.Name}' added."));
        }
Example #17
0
        public async Task AddCommander(Commander commander)
        {
            await _context.AddAsync(commander);

            await _context.SaveChangesAsync();

            await Task.CompletedTask;
        }
Example #18
0
        public async Task AddReport(Report report)
        {
            await _context.AddAsync(report);

            await _context.SaveChangesAsync();

            await Task.CompletedTask;
        }
Example #19
0
        public async Task AddLeave(Leave leave)
        {
            await _context.AddAsync(leave);

            await _context.SaveChangesAsync();

            await Task.CompletedTask;
        }
        public async Task <string> CreateMatch(Match match)
        {
            await _databaseContext.AddAsync(match);

            await _databaseContext.SaveChangesAsync();

            return(match.Id);
        }
Example #21
0
        public async Task <ActionResult <Car> > AddCar([FromBody] Car _car)
        {
            await _db.AddAsync <Car>(_car);

            await _db.SaveChangesAsync();

            return(CreatedAtAction(nameof(GetById), new { id = _car.CarID }, _car));
        }
Example #22
0
        public async Task AddSoldier(Soldier soldier)
        {
            await _context.AddAsync(soldier);

            await _context.SaveChangesAsync();

            await Task.CompletedTask;
        }
        public async Task <LibraryType> Add(LibraryType libraryType)
        {
            await _context.AddAsync(libraryType);

            await _context.SaveChangesAsync();

            throw new NotImplementedException();
        }
Example #24
0
        public async Task AddCompany(Company company)
        {
            await _context.AddAsync(company);

            await _context.SaveChangesAsync();

            await Task.CompletedTask;
        }
Example #25
0
        public async Task <IActionResult> AddUserAsync([FromBody] UserModel userDetails)
        {
            await _databaseContext.AddAsync(userDetails);

            await _databaseContext.SaveChangesAsync();

            return(Ok(true));
        }
Example #26
0
        /// <summary>
        /// Adds and returns a new blacklist filter
        /// </summary>
        /// <param name="regex">The Regex pattern to use</param>
        /// <param name="guild">The guild to use</param>
        /// <returns>The newly added filter</returns>
        public async Task <BlacklistFilter> AddBlacklistFilter(string regex, IGuild guild)
        {
            var entry = await _dbContext.AddAsync(new BlacklistFilter { Content = regex, ServerId = guild.Id });

            await _dbContext.SaveChangesAsync();

            return(entry.Entity);
        }
        public virtual async Task <T> AddAsync(T entity)
        {
            await DbContext.AddAsync(entity);

            await DbContext.SaveChangesAsync();

            return(entity);
        }
Example #28
0
        public async Task AddAdmin(Admin admin)
        {
            await _context.AddAsync(admin);

            await _context.SaveChangesAsync();

            await Task.CompletedTask;
        }
Example #29
0
        public async Task <Product> Post([FromBody] Product product)
        {
            await _context.AddAsync(product);

            await _context.SaveChangesAsync();

            return(product);
        }
Example #30
0
        public async Task <User> Add(User user)
        {
            await _context.AddAsync(user);

            await _context.SaveChangesAsync();

            throw new NotImplementedException();
        }