public InventoryItem PostInventoryItem(AddInventoryItemDto itemDto)
{
ItemImage img = inventoryRepository.GetItemImage(itemDto.ItemImageId);
ItemType type = inventoryRepository.GetItemType(itemDto.ItemTypeId);
/*
* Check if item already exists in Inventory
* Update amount if so.
*/
InventoryItem existingItem = this.inventoryRepository.GetInventoryItemByColor(img);
if (existingItem != null)
{
Console.WriteLine("Existing item was found, we're going to update its amount");
var updateItem = new UpdateInventoryItemDto(
existingItem.ItemImage.ItemImageId,
existingItem.ItemType.ItemTypeId,
existingItem.Amount + itemDto.Amount
);
return(this.UpdateInventoryItem(updateItem, existingItem.InventoryItemId));
}
else
{
Console.WriteLine("Existing item was not found, we're creating a new one");
}
InventoryItem item = new InventoryItem(itemDto.AuthId, img, type, itemDto.Amount);
return(this.inventoryRepository.PostInventoryItem(item));
}
public IActionResult formitem(ItemImage item)
{
c.itemImages.Add(item);
c.SaveChanges();
return(RedirectToAction("Index"));
}
// Start is called before the first frame update
void Start()
{
charfile = GameObject.Find("Image").GetComponent <CharacterImage>();
itemfile = GameObject.Find("Item").GetComponent <ItemImage>();
textbox = GameObject.Find("Text").GetComponent <TextChange>();
scenefile = GameObject.Find("SceneManager").GetComponent <SceneTransition>();
}
public ActionResult Edit([Bind(Include = "Id,Name")] ItemMaster itemMaster, string ItemImageUrl)
{
if (ModelState.IsValid)
{
var itemImage = store.AdminMgr.GetItemImageByItemId(itemMaster.Id);
if (itemImage == null)
{
var itemImgNotNull = !ItemImageUrl.IsNullOrWhiteSpace();
if (itemImgNotNull)
{
var newItemImage = new ItemImage()
{
ItemMasterId = itemMaster.Id,
ImageUrl = ItemImageUrl
};
store.AdminMgr.AddItemImage(newItemImage);
itemImage = store.AdminMgr.GetItemImageByItemId(itemMaster.Id);
}
}
if (store.AdminMgr.EditItemImage(itemImage))
{
if (store.AdminMgr.EditItemMaster(itemMaster))
{
return(RedirectToAction("Index"));
}
}
}
return(View(itemMaster));
}
public void AddReferenceImageItem()
{
ReferenceImageList = new ObservableCollection <ItemImage>();
var referenceImageA = new ItemImage();
referenceImageA.Visibility = Visibility.Visible;
referenceImageA.Name = "A";
referenceImageA.StudyID = "2017";
referenceImageA.Type = "DR";
ReferenceImageList.Add(referenceImageA);
var referenceImageB = new ItemImage();
referenceImageB.Visibility = Visibility.Visible;
referenceImageB.Name = "B";
referenceImageB.StudyID = "2017";
referenceImageB.Type = "DR";
ReferenceImageList.Add(referenceImageB);
var referenceImageC = new ItemImage();
referenceImageC.Visibility = Visibility.Visible;
referenceImageC.Name = "B";
referenceImageC.StudyID = "2017";
referenceImageC.Type = "DR";
ReferenceImageList.Add(referenceImageC);
}
void Update()
{
if (!isLocalPlayer || !equip_action)
{
return;
}
int index = weapons.FindIndex(delegate(Gun g)
{
return(g &&
(Input.inputString.Contains(g.button) ||
(Input.GetMouseButtonDown(0) &&
g.button == "LMB")));
});
if (index != -1 && !blocking)
{
Gun gun = weapons[index];
if (gun.HasReloaded())
{
ItemImage image = gun.item_image_show.GetComponentInChildren <ItemImage>();
StartCoroutine(image.Cooldown(gun.reload_time));
CmdShoot(gun.gameObject, gun.barrel_end.forward, gun.barrel_end.position, gun.barrel_end.rotation);
}
}
else if (Input.GetMouseButtonDown(1) && !blocking)
{
CmdStartShieldBlocking();
blocking = true;
}
else if (Input.GetMouseButtonDown(1) && blocking)
{
blocking = false;
CmdEndShieldBlocking();
}
}
//TODO: Move crosshair to here
public HotbarScreen()
{
//Init the hotbar
Hotbar = new UiImage(this, new Point(0, 0), new Point(5, 5), "textures/ui/hotbar_gui");
Hotbar.size = new Point(Hotbar.image.Width, Hotbar.image.Height);
Hotbar.rawSize = Hotbar.size;
Hotbar.UV = new Vector4(0, 0, 0.3515625f, 0.0390625f);
AddComponent(Hotbar);
//init the items
for (int i = 0; i < 9; i++)
{
items[i] = new ItemImage(this, 0, 0, 64, 64);
items[i].rawSize = new Point(16, 16);
AddComponent(items[i]);
}
//init the selection dot
Selected = new UiImage(this, new Point(0, 0), new Point(5, 5), "textures/ui/hotbar_gui");
Selected.size = new Point(Selected.image.Width, Selected.image.Height);
Selected.rawSize = Selected.size;
Selected.UV = new Vector4(0, 0.0625f, 0.04296875f, 0.10546875f);
AddComponent(Selected);
//init the crosshair
CrosshairX = new UiImage(this, Point.Zero, new Point(CrossHairWidth, CrossHairThickness));
CrosshairY = new UiImage(this, Point.Zero, new Point(CrossHairThickness, CrossHairWidth));
AddComponent(CrosshairX);
AddComponent(CrosshairY);
HoverText = new UiText(this, Point.Zero, "");
AddComponent(HoverText);
}
public async Task <IActionResult> Privacy(IFormFile file)
{
ItemImage ıtemImage = new ItemImage();
if (file != null) //post edilen form boş değilse
{
var uzantı = Path.GetExtension(file.FileName); //uzantı aldık
string randomname = string.Format($"{Guid.NewGuid()}{uzantı}"); //ratgele isim belirlendi
ıtemImage.Name = randomname; //file urlsi itemin urlye aktarılır
var path = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot\\img", randomname); // path kaydediliyor
ıtemImage.Url = path;
c.Add(ıtemImage);
c.SaveChanges();
using (var stream = new FileStream(path, FileMode.Create))//dosya dizine kaydediliyor
{
await file.CopyToAsync(stream);
}
}
return(View());
}
// Public Methods
//======================================================================
public void SetImage(ItemImage image)
{
if (null == image)
{
//No image set, so draw one ourselves
this.ImageProvider = new DynamicImage(this.Name, this.Description);
}
else if (!string.IsNullOrEmpty(image.ImageFilePath))
{
if (image.ImageFilePath.EndsWith(".dzi", StringComparison.InvariantCultureIgnoreCase))
{
this.ImageProvider = new DeepZoomImage(image.ImageFilePath);
}
else
{
this.ImageProvider = new FileImage(image.ImageFilePath);
}
}
else if (null != image.ImageUrl)
{
if (image.ImageUrl.LocalPath.EndsWith(".dzi", StringComparison.InvariantCultureIgnoreCase))
{
this.ImageProvider = new DeepZoomImage(image.ImageUrl);
}
else
{
this.ImageProvider = new WebImage(image.ImageUrl);
}
}
}
public async Task <ItemImage> UpdateAsync(ItemImage image)
{
var updated = _context.Images.Update(image);
await _context.SaveChangesAsync();
return(updated.Entity);
}
private void ImgButtonClick(object sender, RoutedEventArgs e)
{
ItemImage popup = new ItemImage();
popup.picture = bitmap;
popup.ShowDialog();
}
public ActionResult CreateItem(Item item1, List <int> item2, List <int> item3, HttpPostedFileBase ImageFileItem)
{
ItemImage ItemImageobj = new ItemImage();
Item_Types Item_Typesobj = new Item_Types();
byte[] buf = null;
foreach (int shopid in item3)
{
item1.shopId = shopid;
context.ShopItem.Add(item1);
context.SaveChanges();
if (ImageFileItem.ContentLength > 0 && !readonce)
{
buf = new byte[ImageFileItem.ContentLength];
ImageFileItem.InputStream.Read(buf, 0, buf.Length);
readonce = true;
}
ItemImageobj.image = buf;
ItemImageobj.imagetype = ImageFileItem.ContentType;
ItemImageobj.itemid = item1.ID;
context.ItemImage.Add(ItemImageobj);
context.SaveChanges();
foreach (int itemtypes in item2)
{
Item_Typesobj.itemId = item1.ID;
Item_Typesobj.itemtypeId = itemtypes;
context.Item_Types.Add(Item_Typesobj);
context.SaveChanges();
}
}
return(RedirectToAction("ChooseShop", "Item"));
}
public IHttpActionResult InsertImage(string id, ItemImage model)
{
//Get the item
var item = db.Items.Find(id);
if (item == null)
{
return(NotFound());
}
if (ModelState.IsValid)
{
model.AddedDate = DateTime.UtcNow;
model.Imagepath = model.Imagepath.Trim();
model.ItemImageId = Guid.NewGuid().ToString();
db.ItemImages.Add(model);
db.SaveChanges();
return(Ok(new
{
Message = "Image has been added successfully!",
Status = "success",
Result = model
}));
}
return(BadRequest("Some properties are not valid"));
}
void ReleaseDesignerOutlets()
{
if (AvailableQuantity != null)
{
AvailableQuantity.Dispose();
AvailableQuantity = null;
}
if (ItemDescription != null)
{
ItemDescription.Dispose();
ItemDescription = null;
}
if (ItemImage != null)
{
ItemImage.Dispose();
ItemImage = null;
}
if (ItemTitle != null)
{
ItemTitle.Dispose();
ItemTitle = null;
}
if (UpdateButton != null)
{
UpdateButton.Dispose();
UpdateButton = null;
}
}
public async Task <IActionResult> PutItemImage([FromRoute] int id, [FromBody] ItemImage itemImage)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != itemImage.Id)
{
return(BadRequest());
}
itemImage.UpdatedAt = DateTimeOffset.Now;
_context.Entry(itemImage).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ItemImageExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(Ok(_context.ItemImages.Find(id)));
}
private void setArrowActive()
{
//Set the loot image to null
ItemImage.GetComponent <Image>().sprite = null;
if (player.actualChestNumber == 0)
{
arrowNext.SetActive(true);
arrowBack.SetActive(false);
}
else if (player.actualChestNumber > 0 && player.actualChestNumber < listAllChest.Count - 1)
{
arrowNext.SetActive(true);
arrowBack.SetActive(true);
}
else if (player.actualChestNumber == listAllChest.Count - 1)
{
arrowNext.SetActive(false);
arrowBack.SetActive(true);
}
//if the chest is lock
if (!canNextChest)
{
arrowNext.SetActive(false);
}
}
public InventoryItem UpdateInventoryItem(UpdateInventoryItemDto itemDto, int itemid)
{
InventoryItem item = this.inventoryRepository.GetInventoryItem(itemid);
ItemImage img = this.inventoryRepository.GetItemImage(itemDto.ItemImageId);
ItemType type = this.inventoryRepository.GetItemType(itemDto.ItemTypeId);
if (item == null)
{
return(null);
}
if (img == null)
{
img = item.ItemImage;
}
if (type == null)
{
type = item.ItemType;
}
item.Amount = itemDto.Amount;
item.ItemType = type;
item.ItemImage = img;
if (item.Amount == 0)
{
this.DeleteInventoryItem(itemid);
return(item);
}
return(this.inventoryRepository.UpdateInventoryItem(item, itemid));
}
public async Task <IActionResult> PostImage(int itemId, [FromBody] byte[] imageData)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
//only user owner can update the image of an item
string userId = User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
if (userId == null)
{
return(Unauthorized());
}
bool owner = await IsUserOwnerAsync(userId, itemId);
if (!owner)
{
return(Forbid());
}
//ad or update item image
var item = await _itemService.FindItemAsync(itemId);
if (item.ImageId == null)
{
//add
var uploaded = await _imageService.InsertImageAsync(new ItemImage()
{
Data = imageData
});
if (uploaded != null)
{
item.ImageId = uploaded.Id;
await _itemService.UpdateItemAsync(item);
return(Ok());
}
}
else
{
//update
ItemImage image = new ItemImage()
{
Id = item.ImageId.Value,
Data = imageData
};
var updated = await _imageService.UpdateImageAsync(image);
if (updated != null)
{
return(Ok());
}
}
return(BadRequest());
}
public void AddImageItems()
{
AllImageList = new ObservableCollection <ItemImage>();
var allImageA = new ItemImage();
allImageA.Visibility = Visibility.Collapsed;
allImageA.Name = "A";
allImageA.StudyID = "2017";
allImageA.Type = "DR";
AllImageList.Add(allImageA);
var allImageB = new ItemImage();
allImageB.Visibility = Visibility.Collapsed;
allImageB.Name = "B";
allImageB.StudyID = "2017";
allImageB.Type = "DR";
AllImageList.Add(allImageB);
var allImageC = new ItemImage();
allImageC.Visibility = Visibility.Collapsed;
allImageC.Name = "C";
allImageC.StudyID = "2017";
allImageC.Type = "DR";
AllImageList.Add(allImageC);
var allImageD = new ItemImage();
allImageD.Visibility = Visibility.Visible;
allImageD.Name = "D";
allImageD.StudyID = "2017";
allImageD.Type = "DR";
AllImageList.Add(allImageD);
var allImageE = new ItemImage();
allImageE.Visibility = Visibility.Collapsed;
allImageE.Name = "A";
allImageE.StudyID = "2017";
allImageE.Type = "DR";
AllImageList.Add(allImageE);
var allImageF = new ItemImage();
allImageF.Visibility = Visibility.Collapsed;
allImageF.Name = "B";
allImageF.StudyID = "2017";
allImageF.Type = "DR";
AllImageList.Add(allImageF);
var allImageG = new ItemImage();
allImageG.Visibility = Visibility.Collapsed;
allImageG.Name = "C";
allImageG.StudyID = "2017";
allImageG.Type = "DR";
AllImageList.Add(allImageG);
}
/// <summary>
/// Populate values from the base palette.
/// </summary>
/// <param name="common">Reference to common settings.</param>
/// <param name="state">State to inherit.</param>
public void PopulateFromBase(KryptonPaletteCommon common,
PaletteState state)
{
common.StateCommon.BackStyle = PaletteBackStyle.ContextMenuItemImage;
common.StateCommon.BorderStyle = PaletteBorderStyle.ContextMenuItemImage;
common.StateCommon.ContentStyle = PaletteContentStyle.ContextMenuItemImage;
ItemImage.PopulateFromBase(state);
}
public async Task <ItemImage> AddAsync(ItemImage image)
{
var added = await _context.Images.AddAsync(image);
await _context.SaveChangesAsync();
return(added.Entity);
}
public ActionResult getImage(int id)
{
List <ItemImage> obj = null;
obj = context.ItemImage.Where(x => x.itemid == id).ToList();
ItemImage a = obj.ElementAt(0);
return(File(a.image, a.imagetype)); // Might need to adjust the content type based on your actual image type
}
public InventoryItem GetInventoryItemByColor(ItemImage image)
{
try {
return(this.context.InventoryItems.First(i => i.ItemImage.Equals(image)));
} catch (Exception e) {
Console.WriteLine(e);
return(null);
}
}
public void InsertItem(ref GameObject item)
{
if (inventory_items.Count < maximum + 1)
{
inventory_items.Add(item);
ItemImage image = item.GetComponentInChildren <ItemImage>();
image.item_script.in_inventory = true;
item.transform.parent = transform;
}
}
public bool EditItemImage(ItemImage itemImage)
{
try
{
return(adminDb.EditItemImage(itemImage));
}
catch
{
return(false);
}
}
private ItemImage DeserializeImage(string[] m)
{
var imageItem = new ItemImage();
imageItem.Id = int.Parse(m[1]);
imageItem.X = double.Parse(m[2]);
imageItem.Y = double.Parse(m[3]);
imageItem.Width = double.Parse(m[4]);
imageItem.Height = double.Parse(m[5]);
imageItem.Data = _base64.ToBytes(m[6]);
return(imageItem);
}
private async void UpdateImage(object state)
{
try
{
Thumbnail = await ItemImage.ToImageSourceAsync();
}
catch (Exception e)
{
Debug.WriteLine(e);
// Ignore - there's already a placeholder thumbnail to be used in case of error.
}
}
public ItemImage CreateNew(string name)
{
var itemImage = new ItemImage()
{
Id = Guid.NewGuid(),
Name = name
};
erpNodeDBContext.ItemImages.Add(itemImage);
erpNodeDBContext.SaveChanges();
return(itemImage);
}
public IHttpActionResult AddAnnouncementImage([FromBody] ItemImage image, long announcementId)
{
try
{
_announcementService.AddAnnouncementImage(image, announcementId);
return(Content(HttpStatusCode.NoContent, ""));
}
catch (Exception e)
{
return(Content(HttpStatusCode.InternalServerError, e.Message));
}
}
public bool AddItemImage(ItemImage itemImage)
{
try
{
db.ItemImages.Add(itemImage);
return(true);
}
catch
{
return(false);
}
}
private void PART_BtOK_Click(object sender, RoutedEventArgs e)
{
try
{
// Delete removed
var tmpActualList = _backgroundImages.Where(x => !x.IsDefault && x.IsCover == _IsCover).ToList();
foreach (ItemImage itemImage in tmpActualList)
{
if (_backgroundImagesEdited.Where(x => x.FullPath == itemImage.FullPath).FirstOrDefault() == null)
{
FileSystem.DeleteFileSafe(itemImage.FullPath);
}
}
// Add newed
for (int index = 0; index < _backgroundImagesEdited.Count; index++)
{
ItemImage itemImage = _backgroundImagesEdited[index];
if (itemImage.FolderName.IsNullOrEmpty() && !itemImage.IsDefault)
{
Guid ImageGuid = Guid.NewGuid();
string OriginalPath = itemImage.Name;
string ext = Path.GetExtension(OriginalPath);
itemImage.Name = ImageGuid.ToString() + ext;
itemImage.FolderName = _gameBackgroundImages.Id.ToString();
itemImage.IsCover = _IsCover;
string Dir = Path.GetDirectoryName(itemImage.FullPath);
if (!Directory.Exists(Dir))
{
Directory.CreateDirectory(Dir);
}
File.Copy(OriginalPath, itemImage.FullPath);
}
}
// Saved
var tmpList = Serialization.GetClone(_gameBackgroundImages.Items.Where(x => x.IsCover != _IsCover).ToList());
tmpList.AddRange(_backgroundImagesEdited);
_gameBackgroundImages.Items = tmpList;
BackgroundChanger.PluginDatabase.Update(_gameBackgroundImages);
((Window)this.Parent).Close();
}
catch (Exception ex)
{
Common.LogError(ex, false, true, "BackgroundChanger");
}
}
public void SaveFileDetails(HttpPostedFileBase file, int id)
{
var newFile = new ItemImage();
newFile.ContentType = file.ContentType;
newFile.ItemID = id;
newFile.ImageBytes = ConvertToBytes(file);
if (file.ContentLength < (1024*1024) &&
(file.ContentType.Contains("/jpg") || file.ContentType.Contains("/jpeg") ||
file.ContentType.Contains("/png") || file.ContentType.Contains("/bmp")))
{
using (var db = new ProjectDatabaseContext())
{
db.ItemImages.AddObject(newFile);
db.SaveChanges();
}
}
}
public ActionResult AddImage(int id)
{
if(Request.Files[0] == null)
throw new ApplicationException("No file found.");
string filePath = _itemImageRepository.SaveImageFile(Request.Files[0].FileName, Request.Files[0].InputStream);
string thumbFilePath = _itemImageRepository.CreateThumb(filePath);
string fileName = Path.GetFileName(filePath);
string thumbFileName = Path.GetFileName(thumbFilePath);
var item = _itemRepository.GetById(id);
var itemImage = new ItemImage() {Filename = fileName, ThumbFilename = thumbFileName};
item.Images.Add(itemImage);
if (item.Images.Count == 1)
item.CoverImage = itemImage;
_itemRepository.Update(item);
_itemRepository.Save();
return RedirectToAction("Edit", new { id = id });
}
private void LoadItemImage()
{
string imageID = Request.QueryString["xID"];
if (imageID == null)
{
SessionObject.RedirectMessage = "No entity ID provided in URL.";
Response.Redirect("~/PortalSelection.aspx", true);
}
else
{
_imageID = GetDecryptedEntityId(X_ID);
SelectedImage = ItemImage.GetImageByID(_imageID);
if (SelectedImage == null)
{
SessionObject.RedirectMessage = "Could not find the image.";
Response.Redirect("~/PortalSelection.aspx", true);
}
else
{
if (SelectedImage.Copyright == "Yes")
{
rbCopyRightYes.Checked = true;
}
else
{
rbCopyRightNo.Checked = true;
trCredit.Style.Add("display", "none");
trSource.Style.Add("display", "none");
trExpiryDate.Style.Add("display", "none");
}
if (!DistrictParms.AllowCopyRightEditOnContentEditor)
{
rbCopyRightNo.Enabled = false;
rbCopyRightYes.Enabled = false;
}
if (SelectedImage.District == 0)
{
hdnFlagDeleteConfirmation.Value = "DELETED";
return;
}
txtName.Text = SelectedImage.Name;
lblFileName.Text = SelectedImage.FileNameOrig;
txtDescription.Text = SelectedImage.Description;
txtKeywords.Text = SelectedImage.Keywords;
lblAuthor.Text = SelectedImage.CreatedByName;
lblDistrict.Text = SelectedImage.SourceName;
txtSource.Text = SelectedImage.Source;
txtCredit.Text = SelectedImage.Credit;
lblExpirationDate.Text = SelectedImage.CopyRightExpiryDate == null
? "No Expiration"
: SelectedImage.CopyRightExpiryDate + "(mm/dd/yyyy)";
lblDateCreated.Text = SelectedImage.DateCreated;
lblDateUpdated.Text = SelectedImage.DateUpdated;
ImageItem.InnerHtml =
Standpoint.Core.Classes.Encryption.EncryptString(
_imageID.ToString(CultureInfo.CurrentCulture));
string sItemImageSrc = AppSettings.UploadFolderWebPath.Replace("/", "") + @"/"
+ SelectedImage.FileName;
previewImg.InnerHtml = @"<img src=""" + sItemImageSrc + @""" />";
ImageSrc.InnerHtml = sItemImageSrc;
uploadFrame.Attributes["src"] = "ContentEditor_ImageUpload.aspx?xID="
+ Standpoint.Core.Classes.Encryption.EncryptInt(
_imageID);
lblName.Text = SelectedImage.Name;
lblDescription.Text = SelectedImage.Description;
lblSize.Text = "";
}
if (Request.QueryString["NewAndReturnType"] != null)
{
string newAndReturnType = Request.QueryString["NewAndReturnType"].ToString(CultureInfo.CurrentCulture);
string newAndReturnID = Request.QueryString["NewAndReturnID"].ToString(CultureInfo.CurrentCulture);
if (newAndReturnType.Length > 0 && newAndReturnID.Length > 0)
{
newAndReturnID = Standpoint.Core.Classes.Encryption.DecryptString(newAndReturnID);
FinishAndReturn.Style.Add("display", "");
}
}
}
}
