public IHttpActionResult SaveEventGenres(int id, [FromBody] IEnumerable <EventGenreModel> models)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var error = ServiceResponce.FromFailed().Result($"Error save tags");
var succes = ServiceResponce.FromSuccess().Result("All save complete");
return(Ok(!_tagService.AddGenreLinks(new EventGenreLinkModel {
IdEvent = id, Genres = models
}) ? error.Response() : succes.Response()));
}
public IHttpActionResult SaveMediaTags(int id, [FromBody] IEnumerable <TagModel> models)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var error = ServiceResponce.FromFailed().Result($"Error save tags");
var succes = ServiceResponce.FromSuccess().Result("All save complete");
return(Ok(!_tagService.AddTagLinks(new TagsPersonMediaModel {
IdMedia = id, Tags = models.ToList()
}) ? error.Response() : succes.Response()));
}
public async Task <ServiceResponce <List <GetCharecterDTO> > > AddCharecter(AddCharecterDTO newCharecter)
{
ServiceResponce <List <GetCharecterDTO> > serviceResponce = new ServiceResponce <List <GetCharecterDTO> >();
Charecter charecter = (_mapper.Map <Charecter>(newCharecter));
charecter.User = await _context.Users.FirstOrDefaultAsync(u => u.Id == GetUserId());
await _context.Charecters.AddAsync(charecter);
await _context.SaveChangesAsync();
serviceResponce.Data = (_context.Charecters.Where(c => c.User.Id == GetUserId()).Select(c => _mapper.Map <GetCharecterDTO>(c))).ToList();
return(serviceResponce);
}
public ServiceResponce GetOrders(ClientDataFilter clientFilter)
{
ServiceResponce retVal = null;
try
{
retVal = _getClient.GetOrders(_machineName, clientFilter);
}
catch (Exception)
{
}
return(retVal);
}
public async Task <ServiceResponce <List <GetPlatformPriceDto> > > AddPlatformPrice(AddPlatformPriceDto newplatformprice)
{
ServiceResponce <List <GetPlatformPriceDto> > serviceResponse = new ServiceResponce <List <GetPlatformPriceDto> >();
PlatformPrice platformprice = _mapper.Map <PlatformPrice>(newplatformprice);
platformprice.IsActive = true;
platformprice.CreatedOn = DateTime.Now;
await _dataContext.PlatformPrices.AddAsync(platformprice);
await _dataContext.SaveChangesAsync();
serviceResponse.Data = await _dataContext.PlatformPrices.Where(x => x.IsActive == true).Select(c => _mapper.Map <GetPlatformPriceDto>(c)).ToListAsync();
return(serviceResponse);
}
public async Task <ServiceResponce <List <HighscoreDTO> > > GetHighscore()
{
List <Charecter> charecters = await _context.Charecters
.Where(c => c.Fights > 0)
.OrderByDescending(c => c.Victories)
.ThenBy(c => c.Defeats)
.ToListAsync();
var response = new ServiceResponce <List <HighscoreDTO> >
{
Data = charecters.Select(c => _mapper.Map <HighscoreDTO>(c)).ToList()
};
return(response);
}
public IHttpActionResult Post(EventModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userId = User.Identity.GetUserId <int>();
var res = _eventService.SaveEvent(model, userId);
var response = res != null?ServiceResponce
.FromSuccess()
.Result("Event save")
.Add("EventId", res.Id) : ServiceResponce.FromFailed().Result("Error save event");
return(Ok(response.Response()));
}
public async Task <ServiceResponce <List <GetCharacterDto> > > AddCharacter(AddCharacterDto newCharacter)
{
ServiceResponce <List <GetCharacterDto> > serviceResponce = new ServiceResponce <List <GetCharacterDto> >();
Character character = _mapper.Map <Character>(newCharacter);
//character.Id = characters.Max(i => i.Id) + 1; not needed since database is in SQL Server
character.User = await _context.Users.FirstOrDefaultAsync(u => u.Id == GetUserId());
await _context.Characters.AddAsync(character);
await _context.SaveChangesAsync();
serviceResponce.Data = _context.Characters.Where(c => c.User.Id == GetUserId()).Select(c => _mapper.Map <GetCharacterDto>(c)).ToList();
return(serviceResponce);
}
//public IHttpContextAccessor Accessor { get; }
public async Task <ServiceResponce <GetCharacterDto> > AddCharacterSkill(AddCharacterSkillDto newCharacterSkillDto)
{
ServiceResponce <GetCharacterDto> responce = new ServiceResponce <GetCharacterDto>();
try
{
Character character = await _context.Characters.Include(c => c.Weapon)
.Include(c => c.Class)
.Include(c => c.CharacterSkills).ThenInclude(cs => cs.Skill)
.FirstOrDefaultAsync(c => c.Id == newCharacterSkillDto.CharacterId &&
c.User.Id == int.Parse(_accessor.HttpContext.User.FindFirstValue(ClaimTypes.NameIdentifier)));
if (character == null)
{
responce.Success = false;
responce.Message = "Character not found.";
return(responce);
}
Skill skill = await _context.Skills
.FirstOrDefaultAsync(s => s.Id == newCharacterSkillDto.SkillId);
if (skill == null)
{
responce.Success = false;
responce.Message = "Skill not found.";
return(responce);
}
CharacterSkill characterSkill = new CharacterSkill
{
Character = character,
Skill = skill,
};
await _context.ChararacterSkills.AddAsync(characterSkill);
await _context.SaveChangesAsync();
responce.Data = _mapper.Map <GetCharacterDto>(character);
}
catch (Exception ex)
{
responce.Success = false;
responce.Message = ex.Message;
}
return(responce);
}
public async Task <ServiceResponce <AttackResultDto> > SkillAttack(SkillAttackDto request)
{
ServiceResponce <AttackResultDto> responce = new ServiceResponce <AttackResultDto>();
try
{
Character attacker = await _context.Characters
.Include(c => c.CharacterSkills).ThenInclude(cs => cs.Skill)
.FirstOrDefaultAsync(c => c.Id == request.AttackerId);
Character opponent = await _context.Characters
.FirstOrDefaultAsync(c => c.Id == request.OpponentId);
CharacterSkill characterSkill =
attacker.CharacterSkills.FirstOrDefault(cs => cs.Skill.Id == request.SkillId);
if (characterSkill == null)
{
responce.Success = false;
responce.Message = $"{attacker.Name} does not have that skill.";
return(responce);
}
int damage = DoSkillAttack(attacker, opponent, characterSkill);
if (opponent.Hitpoints <= 0)
{
responce.Message = $"{opponent.Name} is defeated";
}
_context.Characters.Update(opponent);
await _context.SaveChangesAsync();
responce.Data = new AttackResultDto
{
Attacker = attacker.Name,
AttackerHP = attacker.Hitpoints,
Opponent = opponent.Name,
OpponentHP = opponent.Hitpoints,
Damage = damage
};
}
catch (Exception ex)
{
responce.Success = false;
responce.Message = ex.Message;
}
return(responce);
}
public async Task <ServiceResponce <GetSubscriptionHeadDto> > GetSubscriptionHead(int ID)
{
ServiceResponce <GetSubscriptionHeadDto> serviceResponce = new ServiceResponce <GetSubscriptionHeadDto>();
SubscriptionHead subscriptionhead = await _dataContext.SubscriptionHeads.FirstOrDefaultAsync(c => c.SubscriptionHeadId == ID && c.IsActive == true);
if (subscriptionhead != null)
{
serviceResponce.Data = _mapper.Map <GetSubscriptionHeadDto>(subscriptionhead);
}
else
{
serviceResponce.Success = false;
serviceResponce.Message = "No Record Found";
}
return(serviceResponce);
}
public async Task <IActionResult> Register([FromBody] UserRegisterDto userDto)
{
ServiceResponce <int> responce = await _authRepository.Register(
new User
{
Username = userDto.Username,
},
userDto.Password
);
if (!responce.Success)
{
return(BadRequest(responce));
}
return(Ok(responce));
}
public async Task <ServiceResponce <GetAppsRateDto> > GetAppsRate(int ID)
{
ServiceResponce <GetAppsRateDto> serviceResponce = new ServiceResponce <GetAppsRateDto>();
AppsRate appsrate = await _dataContext.AppsRates.FirstOrDefaultAsync(c => c.AppsRateId == ID && c.IsActive == true);
if (appsrate != null)
{
serviceResponce.Data = _mapper.Map <GetAppsRateDto>(appsrate);
}
else
{
serviceResponce.Success = false;
serviceResponce.Message = "No Record Found";
}
return(serviceResponce);
}
public IHttpActionResult Post([FromBody] HallModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var succes = ServiceResponce.FromSuccess().Result("Concert schedules save complete");
var error = ServiceResponce.FromFailed().Result($"Error save concert schedules");
var res = _concertService.SaveHall(model);
if (res != null)
{
succes.Add("ConcertPlaceId", res.Id);
}
return(Ok(res != null ? succes.Response() : error.Response()));
}
public async Task <ServiceResponce <List <GetAppDto> > > AddApp(AddAppDto newapp)
{
ServiceResponce <List <GetAppDto> > serviceResponse = new ServiceResponce <List <GetAppDto> >();
App app = _mapper.Map <App>(newapp);
app.IsActive = true;
app.CreatedOn = DateTime.Now;
await _dataContext.Apps.AddAsync(app);
await _dataContext.SaveChangesAsync();
serviceResponse.Data = await _dataContext.Apps.Where(x => x.IsActive == true).Select(c => _mapper.Map <GetAppDto>(c)).ToListAsync();
return(serviceResponse);
}
public async Task <ServiceResponce <GetBaseCurrencyDto> > GetBaseCurrency(int ID)
{
ServiceResponce <GetBaseCurrencyDto> serviceResponce = new ServiceResponce <GetBaseCurrencyDto>();
BaseCurrency basecurrency = await _dataContext.BaseCurrencys.FirstOrDefaultAsync(c => c.BaseCurrencyId == ID && c.IsActive == true);
if (basecurrency != null)
{
serviceResponce.Data = _mapper.Map <GetBaseCurrencyDto>(basecurrency);
}
else
{
serviceResponce.Success = false;
serviceResponce.Message = "No Record Found";
}
return(serviceResponce);
}
public async Task <ServiceResponce <List <GetBaseCurrencyDto> > > AddBaseCurrency(AddBaseCurrencyDto newbasecurrency)
{
ServiceResponce <List <GetBaseCurrencyDto> > serviceResponse = new ServiceResponce <List <GetBaseCurrencyDto> >();
BaseCurrency basecurrency = _mapper.Map <BaseCurrency>(newbasecurrency);
basecurrency.IsActive = true;
basecurrency.CreatedOn = DateTime.Now;
await _dataContext.BaseCurrencys.AddAsync(basecurrency);
await _dataContext.SaveChangesAsync();
serviceResponse.Data = await _dataContext.BaseCurrencys.Where(x => x.IsActive == true).Select(c => _mapper.Map <GetBaseCurrencyDto>(c)).ToListAsync();
return(serviceResponse);
}
public async Task <ServiceResponce <GetPlatformPriceDto> > GetPlatformPrice(int ID)
{
ServiceResponce <GetPlatformPriceDto> serviceResponce = new ServiceResponce <GetPlatformPriceDto>();
PlatformPrice platformprice = await _dataContext.PlatformPrices.FirstOrDefaultAsync(c => c.PlatformPriceId == ID && c.IsActive == true);
if (platformprice != null)
{
serviceResponce.Data = _mapper.Map <GetPlatformPriceDto>(platformprice);
}
else
{
serviceResponce.Success = false;
serviceResponce.Message = "No Record Found";
}
return(serviceResponce);
}
public async Task <ServiceResponce <GetCharacterDto> > GetCharacter(int ID)
{
ServiceResponce <GetCharacterDto> serviceResponce = new ServiceResponce <GetCharacterDto>();
//Character character = characters.FirstOrDefault(c => c.Id == ID);
Character character = await _dataContext.Characters.FirstOrDefaultAsync(c => c.Id == ID && c.IsActive == true);
if (character != null)
{
serviceResponce.Data = _mapper.Map <GetCharacterDto>(character);
}
else
{
serviceResponce.Success = false;
serviceResponce.Message = "No Record Found";
}
return(serviceResponce);
}
public IHttpActionResult Post([FromBody] EventModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userId = User.Identity.GetUserId <int>();
var succes = ServiceResponce.FromSuccess().Result("Concert save complete");
var error = ServiceResponce.FromFailed().Result($"Error save concert");
var concert = _concertService.SaveConcert(model, userId);
if (concert == null)
{
return(Ok(error.Response()));
}
succes.Add("concertId", concert.Id);
return(Ok(succes.Response()));
}
public async Task <ServiceResponce <List <GetCharacterDto> > > AddCharacter(AddCharacterDto newcharacter)
{
ServiceResponce <List <GetCharacterDto> > serviceResponse = new ServiceResponce <List <GetCharacterDto> >();
Character character = _mapper.Map <Character>(newcharacter);
//character.Id = characters.Max(c => c.Id) + 1;
//characters.Add(character);
//serviceResponse.Data = characters.Select(c=>_mapper.Map<GetCharacterDto>(c)).ToList();
character.IsActive = true;
character.CreatedOn = DateTime.Now;
await _dataContext.Characters.AddAsync(character);
await _dataContext.SaveChangesAsync();
serviceResponse.Data = await _dataContext.Characters.Where(x => x.IsActive == true).Select(c => _mapper.Map <GetCharacterDto>(c)).ToListAsync();
return(serviceResponse);
}
public async Task<ServiceResponce<List<GetCharacterDto>>> DeleteCharacter(int id)
{
var serviceResponce = new ServiceResponce<List<GetCharacterDto>>();
try
{
Character character = await _context.Characters.FirstAsync(x => x.Id == id);
_context.Characters.Remove(character);
await _context.SaveChangesAsync();
serviceResponce.Data = _context.Characters.Select(c => _mapper.Map<GetCharacterDto>(c)).ToList();
}
catch (Exception ex)
{
serviceResponce.Success = false;
serviceResponce.Message = ex.Message;
}
return serviceResponce;
}
public IHttpActionResult UpdateDescriptions(int id, [FromBody] PersonDescriptionModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userId = User.Identity.GetUserId <int>();
var descrId = _personService.UpdateDescriptions(model, userId);
if (id <= 0 && descrId > 0)
{
return(Ok(descrId));
}
if (descrId <= 0 || !_personService.LinkDescriptions(id, descrId))
{
return(Ok(ServiceResponce.FromFailed().Result($"Error save description").Response()));
}
return(Ok(descrId));
}
public async Task <ServiceResponce <int> > Register(User user, string password)
{
ServiceResponce <int> responce = new ServiceResponce <int>();
if (await UserExists(user.Username))
{
responce.Success = false;
responce.Message = "User Already Exists";
return(responce);
}
Utility.CreatePasswordHash(password, out byte[] passwordHash, out byte[] passwordSalt);
user.PasswordHash = passwordHash;
user.PasswordSalt = passwordSalt;
await _context.AddAsync(user);
await _context.SaveChangesAsync();
responce.Data = user.Id;
return(responce);
}
public async Task <ServiceResponce <string> > Login(string username, string password)
{
var response = new ServiceResponce <string>();
var user = await _context.Users.FirstOrDefaultAsync(x => x.Username.ToLower().Equals(username.ToLower()));
if (user == null)
{
response.Success = false;
response.Message = "User Not Found!";
}
else if (!VerifyPasswordHash(password, user.PasswordHash, user.PasswordSalt))
{
response.Success = false;
response.Message = "Incorrect Password!";
}
else
{
response.Data = user.Id.ToString();
}
return(response);
}
public async Task <ServiceResponce <GetBaseCurrencyDto> > UpdateBaseCurrency(UpdatedBaseCurrencyDto updatedBaseCurrency)
{
ServiceResponce <GetBaseCurrencyDto> serviceResponce = new ServiceResponce <GetBaseCurrencyDto>();
try {
BaseCurrency basecurrency = await _dataContext.BaseCurrencys.FirstOrDefaultAsync(c => c.BaseCurrencyId == updatedBaseCurrency.BaseCurrencyId && c.IsActive == true);
basecurrency.BaseCurrencyCode = updatedBaseCurrency.BaseCurrencyCode;
basecurrency.LastModifiedBy = updatedBaseCurrency.LastModifiedBy;
basecurrency.LastModifiedon = DateTime.Now;
_dataContext.BaseCurrencys.Update(basecurrency);
await _dataContext.SaveChangesAsync();
serviceResponce.Data = _mapper.Map <GetBaseCurrencyDto>(basecurrency);
}
catch (Exception e) {
serviceResponce.Success = false;
serviceResponce.Message = e.Message;
}
return(serviceResponce);
}
public async Task <ServiceResponce <string> > Login(string username, string password)
{
ServiceResponce <string> responce = new ServiceResponce <string>();
User user = await _context.Users.FirstOrDefaultAsync(x => x.Username.ToLower().Equals(username.ToLower()));
if (user == null)
{
responce.Success = false;
responce.Message = "User not found.";
}
else if (!VerifyPasswordHash(password, user.PasswordHash, user.PasswordSalt))
{
responce.Success = false;
responce.Message = "Wrong password.";
}
else
{
responce.Data = CreateToken(user);
}
return(responce);
}
public async Task <ServiceResponce <List <GetAppsRateDto> > > DeleteAppsRate(int ID)
{
ServiceResponce <List <GetAppsRateDto> > serviceResponce = new ServiceResponce <List <GetAppsRateDto> >();
try
{
AppsRate appsrate = await _dataContext.AppsRates.FirstAsync(c => c.AppsRateId == ID);
appsrate.IsActive = false;
appsrate.LastModifiedon = DateTime.Now;
_dataContext.AppsRates.Update(appsrate);
await _dataContext.SaveChangesAsync();
serviceResponce.Data = await(_dataContext.AppsRates.Where(x => x.IsActive == true).Select(c => _mapper.Map <GetAppsRateDto>(c))).ToListAsync();
}
catch (Exception e)
{
serviceResponce.Success = false;
serviceResponce.Message = e.Message;
}
return(serviceResponce);
}
public async Task <ServiceResponce <List <GetBaseCurrencyDto> > > DeleteBaseCurrency(int ID)
{
ServiceResponce <List <GetBaseCurrencyDto> > serviceResponce = new ServiceResponce <List <GetBaseCurrencyDto> >();
try
{
BaseCurrency basecurrency = await _dataContext.BaseCurrencys.FirstAsync(c => c.BaseCurrencyId == ID);
basecurrency.IsActive = false;
basecurrency.LastModifiedon = DateTime.Now;
_dataContext.BaseCurrencys.Update(basecurrency);
await _dataContext.SaveChangesAsync();
serviceResponce.Data = await(_dataContext.BaseCurrencys.Where(x => x.IsActive == true).Select(c => _mapper.Map <GetBaseCurrencyDto>(c))).ToListAsync();
}
catch (Exception e)
{
serviceResponce.Success = false;
serviceResponce.Message = e.Message;
}
return(serviceResponce);
}
public async Task <ServiceResponce <GetAppDto> > UpdateApp(UpdatedAppDto updatedApp)
{
ServiceResponce <GetAppDto> serviceResponce = new ServiceResponce <GetAppDto>();
try {
App app = await _dataContext.Apps.FirstOrDefaultAsync(c => c.AppId == updatedApp.AppId && c.IsActive == true);
app.AppName = updatedApp.AppName;
app.AppCode = updatedApp.AppCode;
app.LastModifiedBy = updatedApp.LastModifiedBy;
app.LastModifiedon = DateTime.Now;
_dataContext.Apps.Update(app);
await _dataContext.SaveChangesAsync();
serviceResponce.Data = _mapper.Map <GetAppDto>(app);
}
catch (Exception e) {
serviceResponce.Success = false;
serviceResponce.Message = e.Message;
}
return(serviceResponce);
}
