public async Task <ResultDTO> AddReview([FromBody] ReviewAddDTO model)
{
try
{
var review = _mapper.Map <ReviewAddDTO, Review>(model);
await _context.reviews.AddAsync(review);
await _context.SaveChangesAsync();
return(new ResultDTO
{
Status = 200,
Message = "Posted"
});
}
catch (Exception ex)
{
var temp = new List <string>();
temp.Add(ex.Message);
return(new ResultErrorDTO
{
Status = 500,
Message = "Error",
Errors = temp
});
}
}
public async Task Birthday(DateTime date)
{
var birthday = await _database.Birthday.FirstOrDefaultAsync(owner => owner.UserId == Context.User.Id);
var newBirthday = new Birthday
{
Date = date,
DoDisplay = true,
UserId = Context.User.Id,
User = await _misc.GetOrCreateUser(Context.User.Id)
};
try
{
if (birthday != null)
{
_database.Birthday.Update(newBirthday);
await ReplyAsync("Your birthday has been updated!");
}
else
{
await _database.Birthday.AddAsync(newBirthday);
await ReplyAsync("Your birthday has been added!");
}
await _database.SaveChangesAsync();
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
public async Task GiveCoins(IUser usr, ulong amount)
{
var user = await _miscDb.GetOrCreateUser(Context.User.Id);
var receiver = await _miscDb.GetOrCreateUser(usr.Id);
if (usr.Id == Context.User.Id)
{
await ReplyAsync($"You've sent {amount} coins to yourself");
return;
}
if (user.Coins < amount)
{
await ReplyAsync("You don't have that much coins, use $coins to check them!");
return;
}
user.Coins -= amount;
receiver.Coins += amount;
_db.UserData.Update(receiver);
_db.UserData.Update(user);
await _db.SaveChangesAsync();
await ReplyAsync($"You gave {usr.Username} {amount} coins!");
}
public async Task <IActionResult> PutCar(int id, Car car)
{
if (id != car.Id)
{
return(BadRequest());
}
_context.Entry(car).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CarExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task SelectClass(string userClass)
{
var dbClass = await _database.userclass.FirstOrDefaultAsync(x => x.Name.ToLower() == userClass.ToLower());
if (dbClass == null)
{
await ReplyAsync("This class doesn't exist");
return;
}
//TODO
var gear = await _gearDatabase.GetOrCreateGearAsync(Context.User.Id);
if (gear.UserClass.Name != UserClasses.Pleb)
{
await ReplyAsync("You cannot change your class currently");
return;
}
gear.UserClass = dbClass;
_database.gear.Update(gear);
await _database.SaveChangesAsync();
await ReplyAsync($"You've changed your class to {dbClass.Name}");
}
public async Task <PayPros> Post(int id, [FromBody] PayPros payment)
{
//Get item to be paid from id
var item = new { id = id, balance = 1.00 };
#region PayPros
//Process Payment
EFContext _dbContext = new EFContext();
//Be secure, remove full CC from persistent storage record
string FullCCNum = payment.CreditCardNumber;
payment = PaymentProcessing.EncryptCreditCardNumber(payment);
//Save payment attempt to persistent storage
_dbContext.PayPros.Add(payment);
await _dbContext.SaveChangesAsync();
//Process with paypros
PaymentProcessing payProcessing = new PaymentProcessing(PaymentAccounts.Judicial, PaymentMethods.Web);
payment = payProcessing.Initiate(payment, FullCCNum);
//Save updated payment attempt to persistent storage
_dbContext.PayPros.Update(payment);
await _dbContext.SaveChangesAsync();
#endregion
//Update item if payment is successful
if (payment.responseCode == 1)
{
item.balance = 0.00;
}
return(payment);
}
public async Task <User> AddAsync(User newUser, CancellationToken ct = default(CancellationToken))
{
_context.User.Add(newUser);
await _context.SaveChangesAsync(ct);
return(newUser);
}
public async Task <ActionResult> Create(AddUserViewModel model)
{
if (ModelState.IsValid)
{
var user = await _context.Users.FirstOrDefaultAsync(x => x.Email.Equals(model.Email));
if (user != null)
{
user.Counter++;
_context.Entry(user).State = EntityState.Modified;
await _context.SaveChangesAsync();
}
else
{
_context.Users.Add(new Entities.User
{
Email = model.Email,
Name = model.Name
});
await _context.SaveChangesAsync();
}
return(RedirectToAction("Index"));
}
return(View(model));
}
public async Task <Result> AddUser(User user)
{
var result = new Result();
try
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
await _context.AddAsync <User>(user);
var operationResult = await _context.SaveChangesAsync();
if (operationResult != 1)
{
throw new OperationCanceledException(nameof(operationResult));
}
result.IsCompleted = true;
}
catch (Exception ex)
{
result.Message = _builder.Build(ex.Message, nameof(EFUserRepository), nameof(AddUser));
result.IsCompleted = false;
}
return(result);
}
public async Task <Address> AddAsync(Address newAddress, CancellationToken ct = default(CancellationToken))
{
_context.Address.Add(newAddress);
await _context.SaveChangesAsync(ct);
return(newAddress);
}
public async Task <IActionResult> PutAirport(int id, Airport airport)
{
if (id != airport.ID)
{
return(BadRequest());
}
_context.Entry(airport).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AirportExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> Edit(int id,
[Bind("Id,FirstName,LastName")] Member member)
{
if (id != member.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(member);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MemberExists(member.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(member));
}
public async Task <ResultDTO> AddNewGame([FromBody] GameAddDTO game)
{
Game newGame = new Game();
newGame.GameKey = Guid.NewGuid().ToString();
newGame.Title = game.title;
newGame.Price = game.price;
newGame.Description = game.description;
newGame.ImageURL = game.imageURL;
newGame.Year = game.year;
newGame.Developer = _context.Developers.FirstOrDefault(x => x.Name == game.developer);
newGame.Genre = _context.Genres.FirstOrDefault(x => x.Name == game.genre);
// newDeveloper.Id = _context.Developers.LastOrDefault().Id+1;
await _context.Games.AddAsync(newGame);
await _context.SaveChangesAsync();
return(new ResultDTO
{
Status = 200,
Message = "Item added"
});
}
public async Task <IActionResult> PutTours([FromRoute] long id, [FromBody] Tour tour)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != tour.Id)
{
return(BadRequest());
}
_context.Entry(tour).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TourExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> Create([Bind("Name, Color")] ChannelModel channelModel)
{
UserModel user = await UserManager.GetUserAsync(User);
var existChannel = _context.Channels.Where(c => c.Name == channelModel.Name).Include(c => c.UserAuthor).SingleOrDefault();
if (ModelState.IsValid && (existChannel == null || existChannel.UserAuthor.UserName != user.UserName))
{
channelModel.UserAuthor = user;
_context.Channels.Add(channelModel);
await _context.SaveChangesAsync();
channelModel = _context.Channels.Where(c => c.Name == channelModel.Name).Include(c => c.UserAuthor).Where(c => c.UserAuthor.UserName == user.UserName).Single();
UserChannelModel userChannel = new UserChannelModel();
userChannel.UserID = user.Id;
userChannel.ChannelID = channelModel.ID;
_context.UserChannels.Add(userChannel);
await _context.SaveChangesAsync();
return(Redirect("/Channel/Details/" + channelModel.ID));
}
else
{
ViewBag.info = "kanał już istnieje!";
}
return(View(channelModel));
}
public async Task <UserData> GetOrCreateUser(ulong userId)
{
// var user = await _db.UserData.FirstOrDefaultAsync(user => user.UserId == userId);
var user = await Microsoft.EntityFrameworkCore.EntityFrameworkQueryableExtensions.FirstOrDefaultAsync(_db.UserData, user => user.UserId == userId);
if (user != null)
{
return(user);
}
var userInfo = new UserData
{
UserId = userId,
UserName = _client.GetUser(userId).Username,
Coins = 0,
CurrentQuest = null,
Level = 1,
UserDaily = false,
EggplantDaily = false
};
await _db.UserData.AddAsync(userInfo);
await _db.SaveChangesAsync();
return(userInfo);
}
public async Task <bool> DeleteTeacher(int[] ids)
{
try
{
foreach (var id in ids)
{
var teacher = _context.Teachers.Where((item) => item.Id == id).FirstOrDefault();
if (teacher != null)
{
var group = _context.Groups.FirstOrDefault((item) => item.TeacherId == teacher.Id);
if (group != null)
{
await _groupService.DeleteGroup((int)group.Id);
}
_context.Teachers.Remove(teacher);
await _context.SaveChangesAsync();
var user = _context.Users.FirstOrDefault((item) => item.Id == id);
if (user != null)
{
await _userManager.DeleteAsync(user);
}
}
}
return(true);
}
catch (Exception e)
{
return(false);
}
}
public async Task <ActionResult <Account> > PostAccount(AccountDTO accountDto)
{
var result = await new UsersController(_context).GetUser(accountDto.UserId);
if (result.Value == null)
{
return(NotFound());
}
if (!AccountValidation.CanUserCreateAccount(result.Value))
{
return(ValidationProblem("User's gross monthly income is below the required amount ($1000)"));
}
var account = new Account
{
AccountId = accountDto.AccountId,
AccountLimit = accountDto.AccountLimit,
UserId = accountDto.UserId,
CreationDate = DateTime.Now
};
_context.Accounts.Add(account);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetAccount", new { id = account.AccountId }, account));
}
public async Task <IActionResult> PutStudent(Guid id, Student student)
{
if (id != student.Id)
{
return(BadRequest());
}
_context.Entry(student).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!StudentExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> Create(int?id, [Bind("DescripcionAtencion")] Evolucion evolucion)
{
if (ModelState.IsValid)
{
evolucion.Medico = User.Identity.Name;
evolucion.FechaYHora = DateTime.Now;
evolucion.EstadoAbierto = true;
evolucion.EpisodioId = (int)id;
Episodio e = _context.Episodios.Where(e => e.Id == id).FirstOrDefault();
evolucion.Episodio = e;
evolucion.Notas = new List <Nota>();
if (e.Evoluciones == null)
{
e.Evoluciones = new List <Evolucion>();
}
e.Evoluciones.Add(evolucion);
_context.Add(evolucion);
await _context.SaveChangesAsync();
return(RedirectToAction("Index", new { id }));
}
return(View(evolucion));
}
/// <summary>
/// 删
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public async Task <bool> Del(T entity)
{
db.Entry(entity).State = EntityState.Deleted;
int i = await db.SaveChangesAsync();
return(i > 0);
}
public async Task <ResultDTO> AddActor([FromBody] ActorAddDTO model)
{
try
{
var actor = _mapper.Map <ActorAddDTO, Actor>(model);
await _context.actors.AddAsync(actor);
await _context.SaveChangesAsync();
return(new ResultDTO
{
Status = 200,
Message = "Posted"
});
}
catch (Exception ex)
{
List <string> temp = new List <string>();
temp.Add(ex.Message);
return(new ResultErrorDTO
{
Status = 500,
Message = "Error",
Errors = temp
});
}
}
public async Task <T> Add(T entity, CancellationToken cancellationToken)
{
await entities.AddAsync(entity);
await context.SaveChangesAsync(cancellationToken);
return(entity);
}
/// <summary>
/// Creating a user
/// </summary>
/// <param name="obj">user to create</param>
/// <returns>created user</returns>
public async Task <User> Create(User obj)
{
var added = await context.Users.AddAsync(obj).ConfigureAwait(false);
await context.SaveChangesAsync().ConfigureAwait(false);
return(added.Entity);
}
public async Task <int> CreateAsync(ClassificationCriterionDTO dto)
{
var entity = dto.ConvertToEntity();
_context.Add(entity);
await _context.SaveChangesAsync();
return(entity.Id);
}
/// <summary>
/// Create User
/// </summary>
public async Task <RoleModel> Create(RoleModel insertModel)
{
var role = _mapper.Map <Role>(insertModel);
await _efContext.Role.AddAsync(role);
await _efContext.SaveChangesAsync();
return(insertModel);
}
public async Task <int> CreateAsync(FieldDTO dto)
{
var entity = dto.ConvertToEntity();
_context.Add(entity);
await _context.SaveChangesAsync();
return(entity.Id);
}
public async Task ConfigurePrefix(string prefix)
{
var server = await _miscDb.GetOrCreateServer(Context.Guild.Id);
server.prefix = Char.Parse(prefix);
_dataBase.ServersSettings.Update(server);
await _dataBase.SaveChangesAsync();
await ReplyAsync("Server prefix to H.u.e database");
}
public virtual async Task CreateAsync(T item)
{
if (item == null)
{
throw new Exception("Значения модели не описаны");
}
await _context.Set <T>().AddAsync(item);
await _context.SaveChangesAsync();
}
/// <summary>
/// 更新公司信息
/// </summary>
/// <param name="companyInfo"></param>
/// <returns></returns>
public async Task <JsonResult> UpdateCompanyInfo(CompanyInfo companyInfo)
{
_db.Company.Update(companyInfo);
ResponseTemplate response = new ResponseTemplate();
response.Success = true;
response.Data = await _db.SaveChangesAsync();
return(Json(response));
}