public string GetFormattedKeyFromKittyAndAccessoryCombination(
KittyModel kittyModel,
AccessoryModel accessoryModel
)
{
return(kittyModel.id + "_" + accessoryModel.id);
}
public static void ToggleSelectedAccessoryForKitty(
KittyModel kitty,
AccessoryModel accessory
)
{
var kittyAccessoriesForKitty = KittyAccessoryService.GetModelsByKittyId(
kitty.id
);
// mutate the kittyAccessory objects to ensure only one in the
// group+subgroup is selected and save
foreach (var kittyAccessoryModel in kittyAccessoriesForKitty)
{
if (
kittyAccessoryModel.accessoryGroup == accessory.accessoryGroup &&
kittyAccessoryModel.accessorySubGroup == accessory.accessorySubGroup
)
{
if (kittyAccessoryModel.accessoryId == accessory.id)
{
kittyAccessoryModel.isSelected = !kittyAccessoryModel.isSelected;
}
else
{
kittyAccessoryModel.isSelected = false;
}
}
}
KittyAccessoryService.SaveMultiple(KittyAccessoryService.GetAll());
}
public ActionResult NewAccessoryLot(NewAccessoryLotModel model)
{
if (ModelState.IsValid)
{
using (var db = new BGS_DBContext()) {
string userIdentityId = User.Identity.GetUserId();
var seller = db.Users.Single(u => u.Id == userIdentityId);
for (int i = 0; i < model.LotCount; i++)
{
AccessoryModel newAccessoryModelModel = GameUtilCreater.AccessoryModelFromModel(model);
db.AccessoryModels.Add(newAccessoryModelModel);
db.SaveChanges();
var lot = new LotModel()
{
Seller = seller,
ItemId = newAccessoryModelModel.Id,
Price = model.Price,
SellerId = seller.GameId,
Status = LotStatus.Available,
Type = LotType.Accessory
};
db.LotModels.Add(lot);
db.SaveChanges();
newAccessoryModelModel.LotId = lot.Id;
}
db.SaveChanges();
return(RedirectToAction("Index", "Market"));
}
}
ModelState.AddModelError("", "Что то не правильно");
return(View(model));
}
/// <summary>
/// Patches the accessory texture.
/// </summary>
/// <param name="accessory">Current accessory patch</param>
/// <param name="accessoryTextureX">X where texture is being patched</param>
/// <param name="accessoryTextureY">Y where texture is being patched</param>
private void PatchAccessoryTexture(AccessoryModel accessory, int accessoryTextureX, int accessoryTextureY)
{
Asset.AsImage().PatchImage(
accessory.Texture,
new Rectangle(accessoryTextureX, accessoryTextureY, SingleAccessoryWidth, SingleAccessoryHeight),
new Rectangle(AccessoryTextureWidth, AccessoryTextureHeight, SingleAccessoryWidth, SingleAccessoryHeight));
}
public IHttpActionResult GetHouseInfoById(int houseId)
{
var rooms = _roomService.GetRoomsByHouseId(houseId).ToList();
var accessories = _accessoryService.GetAccessoriesByHouseId(houseId).ToList();
var result = new HouseModel {
id = houseId, rooms = new List <RoomModel>()
};
foreach (var room in rooms)
{
var roomModel = new RoomModel();
var belongingAccessories = accessories.Where(u => u.RoomId == room.Id).ToList();
roomModel.accessories = new List <AccessoryModel>();
foreach (var accessory in belongingAccessories)
{
var accessoryModel = new AccessoryModel
{
name = accessory.Name,
pin = accessory.Pin,
status = accessory.Status
};
roomModel.accessories.Add(accessoryModel);
}
result.rooms.Add(roomModel);
}
return(Ok(result));
}
private void MaxTypeCountCheck(object obj)
{
bool validstatis = true;
int typecount = 0;
if (ListAccessory != null)
{
var selectedrowobj = (AccessoryModel)obj;
var selectedItems = (from s in ListAccessory where s.IsSelect == true select s).ToList();
foreach (AccessoryModel accessory1 in selectedItems)
{
typecount = 0;
if (accessory1.IsSelect == false)
{
continue;
}
selectedrowobj = accessory1;
if (selectedItems.Count > 0 && selectedrowobj != null)
{
foreach (AccessoryModel accessory in selectedItems)
{
if (selectedrowobj.Description == accessory.Description)
{
typecount += accessory.Count;
}
}
if (typecount > selectedrowobj.MaxCount)
{
validstatis = false;
}
else
{
// AddButtonEnable = true;
}
}
}
var selectedrowobjmsg = new AccessoryModel();
if (obj != null)
{
selectedrowobjmsg = (AccessoryModel)obj;
}
if (validstatis == true)
{
AddButtonEnable = true;
}
else if (obj == null)
{
AddButtonEnable = false;
}
else if (selectedrowobjmsg.IsSelect == true)
{
AddButtonEnable = false;
JCHMessageBox.Show("selected count is greater than max count of type ");
}
}
}
// chose, at random, one item among the
// locked accessories and locked kitties for unlock
private void UnlockRandomKittyOrAccessory()
{
// chance list for calculating selection of kitty or accessory for unlock
var selectBetweenList = new List <int>();
// gather objects
var allKitties = KittyService.GetAll();
var selectedKitty = KittyService.GetSelected();
var accessoriesForKitty = AccessoryService.GetAccessoriesForKitty(selectedKitty);
// filter for locked kitties and accessories
var lockedKitties = new List <KittyModel>();
foreach (var kitty in allKitties)
{
if (!kitty.isUnlocked)
{
lockedKitties.Add(kitty);
selectBetweenList.Add(1);
}
}
var lockedAccessoriesForKitty = new List <AccessoryModel>();
foreach (var accessory in accessoriesForKitty)
{
var kittyAccessory = KittyAccessoryService.GetModelByKittyAndAccessoryCombination(
selectedKitty,
accessory
);
if (!kittyAccessory.isUnlocked)
{
lockedAccessoriesForKitty.Add(accessory);
selectBetweenList.Add(2);
}
}
// select whether kitty or accessory will be unlocked
int randomSelectionIndex = Random.Range(0, selectBetweenList.Count);
int selectedType = selectBetweenList[randomSelectionIndex];
if (selectedType == 1)
{
// unlock random locked kitty
randomSelectionIndex = Random.Range(0, lockedKitties.Count);
this.unlockedKittyModel = lockedKitties[randomSelectionIndex];
this.unlockedKittyModel.isUnlocked = true;
KittyService.Save(this.unlockedKittyModel);
}
else
{
// unlock random accessory for kitty
randomSelectionIndex = Random.Range(0, lockedAccessoriesForKitty.Count);
this.unlockedAccessoryModel = lockedAccessoriesForKitty[randomSelectionIndex];
var kittyAccessoryToUnlock = KittyAccessoryService.GetModelByKittyAndAccessoryCombination(
selectedKitty,
this.unlockedAccessoryModel
);
kittyAccessoryToUnlock.isUnlocked = true;
KittyAccessoryService.Save(kittyAccessoryToUnlock);
}
}
public static void Save(AccessoryModel model)
{
var modelsToSave = new List <AccessoryModel>()
{
model
};
AccessoryService.SaveMultiple(modelsToSave);
}
private static void DefineAccessoryToAccessoryModelMapping()
{
MapperObject.AddMap <Accessory, AccessoryModel>(src =>
{
var res = new AccessoryModel();
res.InjectFrom(src);
res.TenantDomain = src.DomainId;
return(res);
});
}
public async Task <IActionResult> ConfirmDeleteFromAccessories_list(int?id)
{
if (id != null)
{
AccessoryModel find_part = await PartsContext.Accessories.FirstOrDefaultAsync(p => p.Id == id);
return(DeleteView(find_part, "Accessories_list"));
}
return(NotFound());
}
public async Task <IActionResult> DeleteAccessories_list(int?id)
{
if (id != null)
{
AccessoryModel find_part = new AccessoryModel {
Id = id.Value
};
await DeletePart(find_part);
return(RedirectToAction("Index"));
}
return(NotFound());
}
public async void CreatePostAndVerifyCreated()
{
var client = GetClient();
var request = RestSharpApiClientHelper.BuildBoschBlueRequest(Method.POST, "api/accessories/");
var anAccessory = new AccessoryModel {
Name = "A test accessory"
};
request.AddJsonBody(anAccessory);
var response = await client.Execute(request);
Assert.True(response.StatusCode == HttpStatusCode.Created);
Assert.NotNull(response.Content);
_host.Dispose();
}
public async void CreateUpdateAndVerify()
{
var client = GetClient();
var postRequest = RestSharpApiClientHelper.BuildBoschBlueRequest(Method.POST, "api/accessories/");
string modelNumber = "ACC" + RandomNumberHelper.NextInteger();
var theAccessory = new AccessoryModel {
Name = "A Power Accessory", ModelNumber = modelNumber, TenantDomain = BoschTenants.BoschBlueDomain
};
postRequest.AddJsonBody(theAccessory);
var postResponse = await client.Execute(postRequest);
Assert.NotNull(postResponse);
Assert.NotNull(postResponse.Content);
Assert.True(postResponse.StatusCode == HttpStatusCode.Created);
_logger.LogDebug($"Created test accessory for model id: {modelNumber}");
var accessoryModelRequest =
RestSharpApiClientHelper.BuildBoschBlueRequest(Method.GET, $"api/accessories/{modelNumber}");
accessoryModelRequest.AddParameter("QueryBy", "ModelNumber", ParameterType.HttpHeader);
var accessoryModelResponse = await client.Execute <AccessoryModel>(accessoryModelRequest);
Assert.True(accessoryModelResponse.IsSuccess);
_logger.LogDebug($"Retrieved test accessory with an id of: {accessoryModelResponse.Data.AccessoryId}");
var updateRequest = RestSharpApiClientHelper.BuildBoschBlueRequest(Method.PUT,
$"api/accessories/{accessoryModelResponse.Data.AccessoryId}");
var theUpdatedAccessory = accessoryModelResponse.Data;
theUpdatedAccessory.Name = "A Power Accessory (UPDATED)";
updateRequest.AddJsonBody(theUpdatedAccessory);
var updateResponse = await client.Execute(updateRequest);
Assert.NotNull(updateResponse);
Assert.NotNull(updateResponse.Content);
Assert.True(updateResponse.StatusCode == HttpStatusCode.OK);
_logger.LogDebug($"Updated test accessory with an id of: {theUpdatedAccessory.AccessoryId}");
_host.Dispose();
}
// SERVICE FOR KITTY -> ACCESSORY RELATIONSHIPS
public static KittyAccessoryModel GetModelByKittyAndAccessoryCombination(
KittyModel kittyModel,
AccessoryModel accessoryModel
)
{
KittyAccessoryData kittyAccessoryData = GameManager.instance.kittyAccessoryData;
string key = kittyAccessoryData.GetFormattedKeyFromKittyAndAccessoryCombination(
kittyModel,
accessoryModel
);
var keyToModel = kittyAccessoryData.GetKeyToModel();
if (keyToModel.ContainsKey(key))
{
return(keyToModel[key]);
}
return(null);
}
public async Task <IActionResult> GetHospitalInfoAsync([FromBody] GetHospitalInfomRequestDto request)
{
var entity = await new HospitalBiz().GetAsync(request.HospitalGuid);
if (entity == null)
{
return(Failed(ErrorCode.DataBaseError, "数据错误"));
}
var response = entity.ToDto <GetHospitalInfomResponseDto>();
response.HosLevel = response.HosLevel?.ToLower();
var richtextModel = await new RichtextBiz().GetAsync(entity.HosDetailGuid);
response.Content = richtextModel?.Content;
AccessoryModel accessory = await new AccessoryBiz().GetAsync(entity.LogoGuid);
response.LogoUrl = $"{accessory?.BasePath}{accessory?.RelativePath}";
return(Success(response));
}
public async Task <IActionResult> CreateAccessory([FromBody] AccessoryModel model)
{
if (!ModelState.IsValid)
{
return(new BadRequestObjectResult(ModelState));
}
try
{
var accessoryData = JobAssistantMapper.Map <Accessory>(model);
await _repo.Create(accessoryData);
}
catch (Exception e)
{
_logger.LogError(1, e, "Failed to create accessory in DB repository");
throw;
}
return(CreatedAtRoute(new { id = model.AccessoryId }, model));
}
/// <summary>
/// Creates the accessory model by loading files.
/// </summary>
private void CreateAccessoryModel()
{
Accessory = CurrentContentPack.ReadJsonFile <AccessoryModel>("Accessories/accessories.json");
Accessory.Texture = CurrentContentPack.LoadAsset <Texture2D>("Accessories/accessories.png");
}
public ActionResult BuyLot(int lotId)
{
using (var db = new BGS_DBContext())
{
var id = User.Identity.GetUserId();
var lot = db.LotModels.Single(p => p.Id == lotId);
User user = db.Users.Single(u => u.Id == id);
if (user.AccountBalance - lot.Price > 0)
{
switch (lot.Type)
{
default: throw new Exception("No this lot");
case LotType.Unit:
UnitModel unitModel = db.UnitModels.Single(u => u.LotId == lotId);
unitModel.LotId = null;
unitModel.Owner = user;
break;
case LotType.Armor:
ArmorModel armorModel = db.ArmorModels.Single(u => u.LotId == lotId);
armorModel.LotId = null;
armorModel.Owner = user;
break;
case LotType.Accessory:
AccessoryModel accessoryModel = db.AccessoryModels.Single(u => u.LotId == lotId);
accessoryModel.LotId = null;
accessoryModel.Owner = user;
break;
case LotType.Weapon:
WeaponModel weaponModel = db.WeaponModels.Single(u => u.LotId == lotId);
weaponModel.LotId = null;
weaponModel.Owner = user;
break;
case LotType.Storage:
StorageModel storageModel = db.StorageModels.Single(u => u.LotId == lotId);
storageModel.LotId = null;
storageModel.Owner = user;
break;
case LotType.Modification:
AimModificationModel aim = db.AimModificationModels.SingleOrDefault(a => a.LotId == lot.Id);
MagazineModificationModel magazine = db.MagazineModificationModels.SingleOrDefault(a => a.LotId == lot.Id);
BarrelModificationModel barrel = db.BarrelModificationModels.SingleOrDefault(a => a.LotId == lot.Id);
ButtModificationModel butt = db.ButtModificationModels.SingleOrDefault(a => a.LotId == lot.Id);
if (aim != null)
{
aim.LotId = null; aim.Owner = user;
}
if (magazine != null)
{
magazine.LotId = null; magazine.Owner = user;
}
if (barrel != null)
{
barrel.LotId = null; barrel.Owner = user;
}
if (butt != null)
{
butt.LotId = null; butt.Owner = user;
}
break;
}
lot.Status = LotStatus.Closed;
lot.BuyerId = user.GameId;
user.AccountBalance -= lot.Price;
lot.Seller.AccountBalance += lot.Price;
db.SaveChanges();
return(RedirectToAction("Index", "Market",
new { buy = $"Лот #{lot.Id} успешно куплен за {lot.Price}$4" }));
}
else
{
return(RedirectToAction("Index", "Market",
new { error = "У вас не хватает средств для этой покупки" }));
}
}
}
private void AccessoryStartupProcesses()
{
var accessoriesToSave = new List <AccessoryModel>();
foreach (string accessoryGroup in AccessoryService.accessoryGroups)
{
foreach (string accessorySubGroup in AccessoryService.accessorySubGroups)
{
// load accessory sprites from Resources
string addressDir = AccessoryService.GetFormattedAssetDirectory(
accessoryGroup,
accessorySubGroup
);
List <Sprite> accessorySprites =
Resources.LoadAll(addressDir, typeof(Sprite))
.Cast <Sprite>()
.ToList();
// Debug.Log("count accessory sprites: " + accessorySprites.Count.ToString());
foreach (Sprite accessorySprite in accessorySprites)
{
// create accessory models if they don't yet exist
var accessoryModel = AccessoryService.GetModelByAssetName(
accessorySprite.name
);
if (accessoryModel == null)
{
accessoryModel = new AccessoryModel(
System.Guid.NewGuid().ToString(),
accessorySprite.name,
AccessoryService.GetFormattedAssetAddress(
accessoryGroup,
accessorySubGroup,
accessorySprite.name
),
AccessoryService.GetFormattedThumbAssetAddress(
accessoryGroup,
accessorySubGroup,
accessorySprite.name
),
accessoryGroup,
accessorySubGroup
);
accessoriesToSave.Add(accessoryModel);
}
// register assets
AssetService.SetSprite(
AccessoryService.GetFormattedAssetAddress(
accessoryGroup,
accessorySubGroup,
accessorySprite.name
),
accessorySprite
);
}
// save thumb accessory sprites to Asset service
string thumbAddressDir = AccessoryService.GetFormattedThumbAssetDir(
accessoryGroup,
accessorySubGroup
);
List <Sprite> accessoryThumbSprites =
Resources.LoadAll(thumbAddressDir, typeof(Sprite))
.Cast <Sprite>()
.ToList();
foreach (var accessoryThumbSprite in accessoryThumbSprites)
{
string thumbAddress = AccessoryService.GetFormattedThumbAssetAddress(
accessoryGroup,
accessorySubGroup,
accessoryThumbSprite.name,
true
);
AssetService.SetSprite(
thumbAddress,
accessoryThumbSprite
);
}
}
}
// insert accessories to be saved
AccessoryService.SaveMultiple(accessoriesToSave);
}
/// <summary>
/// 更新附件记录
/// </summary>
/// <param name="accessoryModel">附件对象实例</param>
/// <returns>返回是否成功</returns>
public bool UpdateAccessoryModel(AccessoryModel accessoryModel)
{
accessoryModel.LastUpdatedDate = DateTime.Now;
return(accessoryModel.Update() == 1);
}
