public DougResponse Give(Command command)
{
var target = _userRepository.GetUser(command.GetTargetUserId());
var user = _userRepository.GetUser(command.UserId);
var position = int.Parse(command.GetArgumentAt(1));
var inventoryItem = user.InventoryItems.SingleOrDefault(itm => itm.InventoryPosition == position);
if (inventoryItem == null)
{
return(new DougResponse(string.Format(DougMessages.NoItemInSlot, position)));
}
if (!inventoryItem.Item.IsTradable)
{
return(new DougResponse(DougMessages.ItemNotTradable));
}
_inventoryRepository.RemoveItem(user, position);
_inventoryRepository.AddItem(target, inventoryItem.Item);
var message = string.Format(DougMessages.UserGaveItem, _userService.Mention(user), inventoryItem.Item.Name, _userService.Mention(target));
_slack.BroadcastMessage(message, command.ChannelId);
return(new DougResponse());
}
public async Task <AddItemResponse> AddItem(AddItemRequest request)
{
try
{
Validate(request.Item);
var itemToBeAdded = new Item()
{
Name = request.Item.Name,
Description = request.Item.Description,
Price = Convert.ToDecimal(request.Item.Price)
};
var addedItemId = await _inventoryRepository.AddItem(itemToBeAdded);
return(new AddItemResponse()
{
AddedItemId = addedItemId
});
}
catch (Exception ex)
{
return(new AddItemResponse()
{
ErrorMessage = ex.Message
});
}
}
public async Task <IHttpActionResult> Post(Item model)
{
try
{
if (await _repository.GetItemAsync(model.ItemId) != null)
{
ModelState.AddModelError("ItemId", "Id in use");
}
if (ModelState.IsValid)
{
_repository.AddItem(model);
if (await _repository.SaveChangesAsync())
{
return(CreatedAtRoute("GetItem", new { id = model.ItemId }, model));
}
}
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
return(BadRequest(ModelState));
}
public InventoryDto AddItem(InventoryDto item)
{
item.AddedDate = DateTime.Parse(item.AddedDate.ToString());
item.UpdatedDate = DateTime.Parse(item.UpdatedDate.ToString());
var response = _inventoryRepository.AddItem(mapper.Map<Inventory>(item));
item.Id = response.Id;
return item;
}
public void EndLottery()
{
var users = _userRepository.GetUsers();
var winner = _randomService.DrawLotteryWinner(users);
_userRepository.ClearTickets();
_inventoryRepository.AddItem(winner, new Item {
Id = "lottery_box"
});
_slack.BroadcastMessage(string.Format(DougMessages.LotteryWinner, _userService.Mention(winner)), General);
}
public string Give(User user, User target, int itemPosition, string channel)
{
var inventoryItem = user.InventoryItems.SingleOrDefault(itm => itm.InventoryPosition == itemPosition);
if (inventoryItem == null)
{
return(string.Format(DougMessages.NoItemInSlot, itemPosition));
}
if (!inventoryItem.Item.IsTradable)
{
return(DougMessages.ItemNotTradable);
}
_inventoryRepository.RemoveItem(user, itemPosition);
_inventoryRepository.AddItem(target, inventoryItem.Item);
var message = string.Format(DougMessages.UserGaveItem, _userService.Mention(user), inventoryItem.Item.GetDisplayName(), _userService.Mention(target));
_slack.BroadcastMessage(message, channel);
return(string.Empty);
}
public void Buy(Interaction interaction)
{
var user = _userRepository.GetUser(interaction.UserId);
var item = _itemFactory.CreateItem(interaction.Value);
if (!user.HasEnoughCreditsForAmount(item.Price))
{
var message = user.NotEnoughCreditsForAmountResponse(item.Price);
_slack.SendEphemeralMessage(message, user.Id, interaction.ChannelId);
return;
}
_userRepository.RemoveCredits(user.Id, item.Price);
_inventoryRepository.AddItem(user, item.Id);
}
public void AddItem(int playerId, int itemId, int count = 1)
{
var inventory = _inventoryRepository.GetInventory(playerId);
var freeSlot = GetFreeInventorySlot(inventory);
if (freeSlot > -1)
{
_inventoryRepository.AddItem(playerId, itemId, count, freeSlot);
}
var player = _userRepository.GetPlayerById(playerId);
if (player != null)
{
_inventorySender.SendInventory(player);
}
}
public DougResponse Craft(List <InventoryItem> items, User user)
{
var recipeId = items.OrderBy(item => item.ItemId).Aggregate(string.Empty, (acc, elem) => acc + elem.ItemId);
var recipe = _recipeRepository.GetRecipeById(recipeId);
if (recipe == null)
{
return(new DougResponse(DougMessages.FailedCrafting));
}
var result = _itemRepository.GetItem(recipe.Result);
_inventoryRepository.RemoveItems(user, items.Select(item => item.InventoryPosition));
_inventoryRepository.AddItem(user, result);
return(new DougResponse(string.Format(DougMessages.SuccessCrafting, result.GetDisplayName())));
}
public DougResponse Buy(User user, string itemId)
{
var item = _itemRepository.GetItem(itemId);
var price = _governmentService.GetPriceWithTaxes(item);
if (!user.HasEnoughCreditsForAmount(price))
{
return(new DougResponse(user.NotEnoughCreditsForAmountResponse(price)));
}
_creditsRepository.RemoveCredits(user.Id, price);
_inventoryRepository.AddItem(user, item);
_governmentService.CollectSalesTaxes(item);
return(new DougResponse());
}
public void Revolution(string channel)
{
var government = _governmentRepository.GetGovernment();
var oldRuler = _userRepository.GetUser(government.Ruler);
var newRuler = _userRepository.GetUser(government.RevolutionLeader);
var crown = _itemRepository.GetItem(CrownId);
if (oldRuler.Id == newRuler.Id)
{
return;
}
if (government.IsInRevolutionCooldown())
{
return;
}
if (oldRuler.Loadout.HeadId == CrownId)
{
_equipmentRepository.UnequipItem(oldRuler, EquipmentSlot.Head);
}
else
{
var crownItem = oldRuler.InventoryItems.SingleOrDefault(inventoryItem => inventoryItem.Item.Id == CrownId);
if (crownItem != null)
{
_inventoryRepository.RemoveItem(oldRuler, crownItem.InventoryPosition);
}
}
_inventoryRepository.AddItem(newRuler, crown);
_slack.BroadcastMessage(string.Format(DougMessages.RevolutionSucceeded, _userService.Mention(oldRuler), _userService.Mention(newRuler)), channel);
_userService.KillUser(oldRuler, channel);
_governmentRepository.Revolution();
}
public IActionResult Post(InventoryItemRPC item)
{
//Quantity in stock
//It isn't enough to only do validation client side, for data integrity it must be done server side as well.
//TODO - Add Post, business logic must be enforced server side as well.
//TODO - Add server side validation
var vehicle = new Vehicle {
Make = (Make)Enum.Parse(typeof(Make), item.Make, true),
Model = item.Model,
Year = item.Year,
VehicleType = (VehicleType)Enum.Parse(typeof(VehicleType), item.Type, true),
RetailPrice = item.RetailPrice,
};
//Parse Features
var features = new List <Feature>();
if (!string.IsNullOrEmpty(item.Fuel))
{
var fuel = FeatureRepository.List.FirstOrDefault(feature => feature.Type == FeatureType.Fuel && feature.Description.Equals(item.Fuel, StringComparison.InvariantCultureIgnoreCase));
if (fuel != null)
{
features.Add(fuel);
}
}
if (!string.IsNullOrEmpty(item.Doors))
{
var doors = FeatureRepository.List.FirstOrDefault(feature => feature.Type == FeatureType.Doors && feature.Description.Equals(item.Doors, StringComparison.InvariantCultureIgnoreCase));
if (doors != null)
{
features.Add(doors);
}
}
if (!string.IsNullOrEmpty(item.Interior))
{
var interior = FeatureRepository.List.FirstOrDefault(feature => feature.Type == FeatureType.Interior && feature.Description.Equals(item.Interior, StringComparison.InvariantCultureIgnoreCase));
if (interior != null)
{
features.Add(interior);
}
}
if (!string.IsNullOrEmpty(item.Transmission))
{
var transmission = FeatureRepository.List.FirstOrDefault(feature => feature.Type == FeatureType.Transmission && feature.Description.Equals(item.Transmission, StringComparison.InvariantCultureIgnoreCase));
if (transmission != null)
{
features.Add(transmission);
}
}
var newItem = new InventoryItem
{
Markup = item.Markup,
Vehicle = vehicle,
Features = features
};
//Assign unique stock number...
newItem.StockNumber = StockNumberGenerator.GenerateStockNumber();
InventoryRepository.AddItem(newItem);
return(Ok());
}
