public byte[] Read(ushort itemId)
{
if (_manager.TryGetTarget(out var manager))
{
if (manager.IsOpen)
{
var request = new NvReadCommandRequest(itemId);
var response = manager.ExecuteQcdmCommandRequest<NvReadCommandResponse>(request);
if (response != null)
{
var size = ItemsFactory.SizeOfNvItem(itemId);
if (size > 0)
{
size = Math.Min(response.Data.LongLength, size);
var data = new byte[size];
Array.Copy(response.Data, 0, data, 0, size);
return data;
}
return response.Data;
}
}
}
return new byte[0];
}
//----------------------------------------------------------------------------------------------------------
public static void AddProfilePageDetails(UsersDataEntity usersDataObject)
{
ItemsEntity page = new ItemsEntity();
page.ModuleTypeID = (int)ModuleTypes.UsersProfiles;
page.OwnerID = usersDataObject.UserId;
//-----------------------------------------------------
//AddDetails
//----------------------------
ItemsDetailsEntity itemDetailsObject;
if (SiteSettings.Languages_HasArabicLanguages)
{
itemDetailsObject = new ItemsDetailsEntity();
itemDetailsObject.LangID = Languages.Ar;
itemDetailsObject.Title = DynamicResource.GetText("Modules", "PageTitle_UserProfilePage");
itemDetailsObject.ExtraData.Add("");
page.Details[Languages.Ar] = itemDetailsObject;
}
if (SiteSettings.Languages_HasEnglishLanguages)
{
itemDetailsObject = new ItemsDetailsEntity();
itemDetailsObject.LangID = Languages.En;
itemDetailsObject.Title = DynamicResource.GetText("Modules", "PageTitle_UserProfilePage");
itemDetailsObject.ExtraData.Add("");
page.Details[Languages.En] = itemDetailsObject;
}
//-----------------------------------------------------
ItemsModulesOptions UsersProfilesModule = ItemsModulesOptions.GetType((int)ModuleTypes.UsersProfiles);
ItemsFactory.Create(page, UsersProfilesModule);
//-----------------------------------------------------
usersDataObject.ProfilePageID = page.ItemID;
}
public Item Retrieve(int id)
{
SqlConnection sql = connection.Get();
DataTable dt = new DataTable();
SqlDataAdapter adapt = new SqlDataAdapter("select * from [Item_Table]", sql);
adapt.Fill(dt);
ItemsFactory itemsFactory = new ItemsFactory();
Item item = itemsFactory.CreateItem("Burger");
for (int i = 0; i < dt.Rows.Count; i++)
{
item.Id = Convert.ToInt32(dt.Rows[i][0]);//.Cells[0].Value.ToString()) ;
item.Name = dt.Rows[i][1].ToString();
item.price = dt.Rows[i][2].ToString();
item.Category = dt.Rows[i][3].ToString();
if (id == item.Id)
{
sql.Close();
return(item);
}
}
return(null);
////comboBox1.DataSource = dt;
////comboBox1.DisplayMember = "Name";
//ItemData = GetDict(dt);
//comboBox1.Items.AddRange(ItemData.Keys.ToArray());
}
private void InstallerAddedHandler(NewQAInstallerEventData eventData)
{
if (_qaBranch.Equals(eventData.QABranch))
{
this.Items.Insert(0, ItemsFactory.CreateQAInstallerItem(eventData.Installer));
}
}
public void NPCFactoryCreate()
{
ItemsFactory wfactory = new ItemsFactory();
NPCFactory factory = new NPCFactory(wfactory);
var creationProfile = new EntityProfile(10, EntityOccupation.Fisherman, EntityRace.None, 10);
IEntity entity = factory.Create(creationProfile);
}
//----------------------------------------------------------------------------------------------------------
public static int AddSubSitePageDetails(int PageNo, UsersDataEntity usersDataObject)
{
ItemsEntity page = new ItemsEntity();
page.ModuleTypeID = (int)ModuleTypes.SubSitePages;
page.OwnerID = usersDataObject.UserId;
//-----------------------------------------------------
//AddDetails
//----------------------------
ItemsDetailsEntity itemDetailsObject;
if (SiteSettings.Languages_HasArabicLanguages)
{
itemDetailsObject = new ItemsDetailsEntity();
itemDetailsObject.LangID = Languages.Ar;
itemDetailsObject.Title = DynamicResource.GetText("SubSites", "Page_" + PageNo);
itemDetailsObject.ExtraData.Add("");
page.Details[Languages.Ar] = itemDetailsObject;
}
if (SiteSettings.Languages_HasEnglishLanguages)
{
itemDetailsObject = new ItemsDetailsEntity();
itemDetailsObject.LangID = Languages.En;
itemDetailsObject.Title = DynamicResource.GetText("SubSites", "Page_" + PageNo);
itemDetailsObject.ExtraData.Add("");
page.Details[Languages.En] = itemDetailsObject;
}
//-----------------------------------------------------
ItemsModulesOptions subSitePagesModule = ItemsModulesOptions.GetType((int)ModuleTypes.SubSitePages);
ItemsFactory.Create(page, subSitePagesModule);
//-----------------------------------------------------
return(page.ItemID);
}
public static Dictionary <string, object> PhoneLoadItems(QcdmManager manager, int subscription)
{
var items = new Dictionary <string, object>();
foreach (var filePath in ItemsFactory.SupportedEfsFilePaths)
{
var realFilePath = GetEfsFilePath(filePath, subscription);
if (manager.Efs.FileExists(realFilePath))
{
var itemType = ItemsFactory.GetEfsFileType(filePath);
using (var stream = FileUtils.PhoneOpenRead(manager, realFilePath))
{
var item = ItemsBinarySerializer.Deserialize(stream, itemType);
items.Add(itemType.Name, item);
stream.Close();
}
}
}
foreach (var nvItemId in ItemsFactory.SupportedNvItemIds)
{
var itemType = ItemsFactory.GetNvItemType(nvItemId);
using (var stream = NvOpenRead(manager, (ushort)nvItemId))
{
if (stream != null)
{
var item = ItemsBinarySerializer.Deserialize(stream, itemType);
items.Add(itemType.Name, item);
stream.Close();
}
}
}
return(items);
}
public void SerializeWeaponsFactory()
{
ItemsFactory factory = new ItemsFactory();
ItemsFactory clone = Serializer.DeepClone(factory);
Assert.IsNotNull(clone); // fails due to jagged arrays :( figure out new strategy
}
//----------------------------------------------------------
public void AddItems(ItemsModulesOptions itemsModule, int categoryID)
{
//-------------------------------------------------------------
InitialItem.CategoryID = categoryID;
InitialItem.ModuleTypeID = itemsModule.ModuleTypeID;
//-------------------------------------------------------------
for (int i = 0; i < 15; i++)
{
if (SiteSettings.Languages_HasArabicLanguages)
{
InitialItem.Details[Languages.Ar] = InitialItemArDetails;
}
if (SiteSettings.Languages_HasEnglishLanguages)
{
InitialItem.Details[Languages.En] = InitialItemEnDetails;
}
ExecuteCommandStatus status = ItemsFactory.Create(InitialItem, itemsModule);
if (status == ExecuteCommandStatus.Done)
{
if (itemsModule.HasComments)
{
AddComments(itemsModule.ModuleTypeID, InitialItem.ItemID, ModuleBaseTypes.Items);
}
}
}
}
//----------------------------------------------------------
//UpdateTestingDataForStaticPages
//----------------------------------------------------------
public void UpdateTestingDataForStaticPages()
{
ItemsModulesOptions SitePagesModule = ItemsModulesOptions.GetType((int)StandardItemsModuleTypes.SitePages);
//-------------------------------------------------------------
InitialItem.CategoryID = 0;
InitialItem.ModuleTypeID = SitePagesModule.ModuleTypeID;
//-------------------------------------------------------------
foreach (SitePageOptions page in SiteModulesManager.Instance.SitePagesList)
{
if (page.IsAvailabe)
{
InitialItem.ItemID = page.PageID;
if (SiteSettings.Languages_HasArabicLanguages)
{
InitialItem.Details[Languages.Ar] = InitialItemArDetails;
}
if (SiteSettings.Languages_HasEnglishLanguages)
{
InitialItem.Details[Languages.En] = InitialItemEnDetails;
}
ExecuteCommandStatus status = ItemsFactory.Update(InitialItem, SitePagesModule);
if (status == ExecuteCommandStatus.Done)
{
if (page.HasComments)
{
AddComments(SitePagesModule.ModuleTypeID, page.PageID, ModuleBaseTypes.Items);
}
}
}
}
}
//------------------------------------------
#endregion
#region ---------------IPhotoable--------------
public string GetPhotoPath(PhotoTypes photo)
{
if (((string)_PhotoExtension).Length > 0)
{
string photoName = ItemsFactory.CreateItemsPhotoName(_ItemID);
string photoPath = DCSiteUrls.GetPath_ItemsPhotoNormalThumbs(OwnerName, ModuleTypeID, CategoryID, ItemID) + photoName;
switch (photo)
{
case PhotoTypes.Original:
photoPath = DCSiteUrls.GetPath_ItemsPhotoOriginals(OwnerName, ModuleTypeID, CategoryID, ItemID) + Photo;
break;
case PhotoTypes.Thumb:
photoPath = DCSiteUrls.GetPath_ItemsPhotoNormalThumbs(OwnerName, ModuleTypeID, CategoryID, ItemID) + photoName + MoversFW.Thumbs.thumbnailExetnsion;
break;
case PhotoTypes.Big:
photoPath = DCSiteUrls.GetPath_ItemsPhotoBigThumbs(OwnerName, ModuleTypeID, CategoryID, ItemID) + photoName + MoversFW.Thumbs.thumbnailExetnsion;
break;
default:
photoPath = DCSiteUrls.GetPath_ItemsPhotoNormalThumbs(OwnerName, ModuleTypeID, CategoryID, ItemID) + photoName + MoversFW.Thumbs.thumbnailExetnsion;
break;
}
return(photoPath);
}
else
{
return(SiteDesign.NoPhotoPath);
}
}
private void NewRootBranchEventHandler(NewRootBranchEventData eventData)
{
var newItem = ItemsFactory.CreateRootBranchItem(eventData.RootBranch, this);
newItem.IsExpanded = true;
this.Items.Insert(0, newItem);
}
private void SetItemsValues()
{
ItemsFactory.EditItemsForValue(_currentItems, Minimum, Maximum, Value);
CalculatePercentageValue();
_itemsPanel.RenderTransform = new RotateTransform(StartAngle);
}
public void WeaponsFactoryCreateRandomWeapon()
{
ItemsFactory factory = new ItemsFactory();
var creationProfile = new ItemProfile(1, EntityOccupation.Warrior);
IItem item1 = factory.Create(creationProfile);
Assert.IsNotNull(item1);
Assert.AreEqual(item1.Quality, item1.Quality);
}
private static string GetEfsFilePath(string filePath, int subscription)
{
if (ItemsFactory.HasSubscription(filePath))
{
var subscriptionFilePath = (subscription <= 0) ? filePath : $"{filePath}_Subscription{subscription:D2}";
return(subscriptionFilePath);
}
return(filePath);
}
public static Enemy GetMonster(int enemyID)
{
// Animal enemies only drop items (like skins, fangs etc). Gold only from humanoid enemies
switch (enemyID)
{
case 0:
Enemy snake =
new Enemy("Snake", 1, 5, 3, 3, 1, 1, 3, 10, 0, 65, World.EnemyIDSnake, false, 1);
snake.Avatar = @"/Images/Creatures/Enemies/Village/snake.png";
snake.Inventory.Add(ItemsFactory.CreateGameItem(World.EnemyLootIDSnakeSkin));
snake.Inventory.Add(ItemsFactory.CreateGameItem(World.EnemyLootIDSnakeFang));
snake.Inventory.Add(ItemsFactory.CreateGameItem(World.EnemyLootIDSnakeEye));
return(snake);
case 1:
Enemy rat =
new Enemy("Rat", 1, 4, 5, 3, 1, 1, 4, 5, 0, 35, World.EnemyIDRat, false, 1);
rat.Avatar = @"/Images/Creatures/Enemies/Village/rat.png";
rat.Inventory.Add(ItemsFactory.CreateGameItem(World.EnemyLootIDRatSkin));
rat.Inventory.Add(ItemsFactory.CreateGameItem(World.EnemyLootIDRatTail));
return(rat);
case 2:
Enemy goblin =
new Enemy("Goblin", 2, 7, 4, 4, 1, 1, 3, 10, 10, 45, World.EnemyIDGoblin, true, 3);
goblin.Avatar = @"/Images/Creatures/Enemies/Forest/goblin.png";
goblin.Inventory.Add(ItemsFactory.CreateGameItem(World.EnemyLootIDGoblinSkin));
goblin.Inventory.Add(ItemsFactory.CreateGameItem(World.EnemyLootIDGoblinFang));
return(goblin);
case 3:
Enemy wolf =
new Enemy("Wolf", 2, 8, 8, 4, 1, 1, 3, 20, 0, 55, World.EnemyIDWolf, true, 5);
wolf.Avatar = @"/Images/Creatures/Enemies/Forest/wolf.png";
wolf.Inventory.Add(ItemsFactory.CreateGameItem(World.EnemyLootIDWolfSkin));
wolf.Inventory.Add(ItemsFactory.CreateGameItem(World.EnemyLootIDWolfFang));
return(wolf);
case 4:
Enemy rogue =
new Enemy("Rogue", 3, 6, 5, 6, 1, 2, 5, 30, 20, 35, World.EnemyIDRogue, true, 5);
rogue.Avatar = @"/Images/Creatures/Enemies/Forest/rogue.png";
rogue.SkillBook.Add(World.SkillByID(World.SwordSKillIDHeavyStrike));
return(rogue);
case 5:
Enemy forestWisp =
new Enemy("Forest Wisp", 3, 5, 3, 5, 10, 7, 5, 30, 0, 25, 5, false, 3);
forestWisp.Avatar = @"/Images/Creatures/Enemies/Forest/forestWisp.png";
forestWisp.SkillBook.Add(World.SkillByID(World.MagicIDFireball));
forestWisp.Inventory.Add(ItemsFactory.CreateGameItem(World.EnemyLootIDWispDust));
return(forestWisp);
default:
throw new ArgumentException(string.Format("MonsterType '{0}' does not exist", enemyID));
}
}
//-----------------------------------------------
#endregion
#region ---------------LoadData---------------
//-----------------------------------------------
//LoadData
//-----------------------------------------------
protected void LoadData()
{
List<ItemsEntity> itemsList = ItemsFactory.GetMain(ModuleTypeID, ItemsCount, OwnerID);
if (itemsList != null && itemsList.Count > 0)
{
rList.DataSource = itemsList;
rList.DataBind();
}
}
public static Dictionary <string, object> LocalLoadItems(string directoryPath, HashSet <string> configItems)
{
var items = new Dictionary <string, object>();
foreach (var fileUnixPath in ItemsFactory.SupportedEfsFilePaths)
{
var item = ItemsFactory.CreateEfsFile(fileUnixPath);
var itemType = item.GetType();
if (configItems == null || configItems.Contains(itemType.Name))
{
var filePath = fileUnixPath.Replace('/', '\\');
var fileAttribute = EfsFileAttributeUtils.Get(itemType);
var path = fileAttribute == null
? $"{directoryPath}{filePath}"
: PathUtils.BuildPath(directoryPath, filePath, fileAttribute.Permissions,
fileAttribute.IsItemFile ? DirectoryEntryType.ItemFile : DirectoryEntryType.File, false);
if (!File.Exists(path))
{
path = $"{directoryPath}{filePath}";
}
if (File.Exists(path))
{
using (var stream = FileUtils.LocalOpenRead(path))
{
ItemsBinarySerializer.Deserialize(item, stream);
stream.Close();
}
}
items.Add(itemType.Name, item);
}
}
foreach (var nvItemId in ItemsFactory.SupportedNvItemIds)
{
var item = ItemsFactory.CreateNvItem(nvItemId);
var itemType = item.GetType();
if (configItems == null || configItems.Contains(itemType.Name))
{
var nvItemFileName = PathUtils.GetNvItemFileName((ushort)nvItemId);
var path = Path.Combine(directoryPath, nvItemFileName);
if (File.Exists(path))
{
using (var stream = FileUtils.LocalOpenRead(path))
{
ItemsBinarySerializer.Deserialize(item, stream);
stream.Close();
}
}
items.Add(itemType.Name, item);
}
}
return(items);
}
public ProductionBranchExplorerBarItem(IProductionBranch productionBranch, IExplorerBarItem parent, IServiceLocator serviceLocator)
: base(parent, serviceLocator)
{
_productionBranch = productionBranch;
foreach (var env in _productionBranch.GetEnvironments())
{
this.Items.Add(ItemsFactory.CreateProductionEnvironment(env));
}
}
//-----------------------------------------------
#endregion
#region ---------------LoadData---------------
//-----------------------------------------------
//LoadData
//-----------------------------------------------
protected void LoadData()
{
if (!string.IsNullOrEmpty(Request.QueryString["ID"]))
{
int itemID = Convert.ToInt32(Request.QueryString["ID"]);
ItemsEntity item = ItemsFactory.GetObject(itemID, Languages.Unknowen, UsersTypes.Admin, OwnerID);
lblItemTitle.Text = item.Title;
LoadList();
}
}
public void WeaponsFactoryCreateSpecifiedWeapon()
{
ItemsFactory factory = new ItemsFactory();
var creationProfile = new ItemProfile(1, ItemType.Crossbow, ItemQualityCode.Flawless);
IItem item1 = factory.Create(creationProfile);
Assert.IsNotNull(item1);
Assert.AreEqual(creationProfile.qualityCode, item1.Quality);
Assert.AreEqual(creationProfile.Type, item1.Info.TypeCode);
}
protected override IEnumerable <IExplorerBarItem> GetLazyLoadedItems()
{
var items = _qaBranch.GetInstallers().OrderByDescending(i => i.Version)
.Select(i => ItemsFactory.CreateQAInstallerItem(i))
.ToList();
SubscribeToEvent <NewQAInstallerEventData>(InstallerAddedHandler);
return(items);
}
public NPCFactory(ItemsFactory weaponFactory)
{
this.weaponFactory = weaponFactory;
occupationBaseStatsMultiple = new Dictionary <EntityOccupation, float[]>();
this.buildInventoryItemProfiles();
foreach (var occupation in Enum.GetValues(typeof(EntityOccupation)))
{
occupationBaseStatsMultiple.Add((EntityOccupation)occupation, GetRandomDistribution());
}
}
protected override IEnumerable <IExplorerBarItem> GetLazyLoadedItems()
{
var items = _environment.GetInstallers().OrderByDescending(i => i.Version)
.Select(i => ItemsFactory.CreateProductionInstallerItem(i))
.ToList();
SubscribeToEvent <NewProductionInstallerEventData>(InstallerAddedHandler, eventData => _environment.Equals(eventData.Environment));
return(items);
}
//-----------------------------------------------------------
#region --------------LoadData--------------
//---------------------------------------------------------
//LoadData
//---------------------------------------------------------
public void LoadData()
{
List <ItemsEntity> itemsList = ItemsFactory.GetAll(ModuleTypeID, CategoryID, true, OwnerID);
Repeater r = (Repeater)this.FindControl(TemplateID);
if (itemsList != null && itemsList.Count > 0)
{
r.DataSource = itemsList;
r.DataBind();
}
}
//-----------------------------------------------
#endregion
#region ---------------LoadPriorities---------------
//-----------------------------------------------
//LoadPriorities
//-----------------------------------------------
protected void LoadPriorities()
{
int categoryid = -1;
if (trCategoryID.Visible)
{
categoryid = Convert.ToInt32(ddlItemCategories.SelectedValue);
}
int itemsCount = ItemsFactory.GetCount(currentModule.ModuleTypeID, categoryid, OwnerID);
OurDropDownList.LoadPriorities(ddlPriority, itemsCount, true);
}
private void TryTakeItems()
{
if (_itemsPanel != null && ItemsFactory != null)
{
_currentItems = ItemsFactory.GenerateItems(IsIndeterminate);
_itemsPanel.Children.Clear();
foreach (UIElement element in _currentItems)
{
_itemsPanel.Children.Add(element);
}
}
}
//-----------------------------------------------
//Page_Load
//-----------------------------------------------
private void Page_Load(object sender, System.EventArgs e)
{
if (!IsPostBack)
{
if (MoversFW.Components.UrlManager.ChechIsValidIntegerParameter("id"))
{
int itemID = Convert.ToInt32(Request.QueryString["id"]);
Guid OwnerID = SitesHandler.GetOwnerIDAsGuid();
ItemsEntity itemsObject = ItemsFactory.GetObject(itemID, Languages.Unknowen, UsersTypes.Admin, OwnerID);
this.Page.Title = itemsObject.Title;
}
}
}
public static Dictionary <string, object> PhoneLoadItems(QcdmManager manager, int subscription, Logger logger, bool verbose,
HashSet <string> configItems)
{
var items = new Dictionary <string, object>();
foreach (var filePath in ItemsFactory.SupportedEfsFilePaths)
{
var realFilePath = PathUtils.GetEfsFilePath(filePath, subscription);
var itemType = ItemsFactory.GetEfsFileType(filePath);
if (configItems == null || configItems.Contains(itemType.Name))
{
if (manager.Efs.FileExists(realFilePath))
{
using (var stream = FileUtils.PhoneOpenReadMemory(manager, realFilePath))
{
if (verbose)
{
logger.LogInfo(string.Format(Strings.QcdmProcessingFormat, filePath));
}
var item = ItemsBinarySerializer.Deserialize(stream, itemType);
items.Add(itemType.Name, item);
stream.Close();
}
}
}
}
foreach (var nvItemId in ItemsFactory.SupportedNvItemIds)
{
var itemType = ItemsFactory.GetNvItemType(nvItemId);
if (configItems == null || configItems.Contains(itemType.Name))
{
using (var stream = NvOpenRead(manager, (ushort)nvItemId))
{
if (stream != null)
{
if (verbose)
{
logger.LogInfo(string.Format(Strings.QcdmProcessingFormat, itemType.Name));
}
var item = ItemsBinarySerializer.Deserialize(stream, itemType);
items.Add(itemType.Name, item);
stream.Close();
}
}
}
}
return(items);
}
private void button4_Click(object sender, EventArgs e)
{
ItemsFactory itemsFactory = new ItemsFactory();
item = itemsFactory.CreateItem(comboBox2.Text);
item.Id = Convert.ToInt32(textBox5.Text.Trim());
item.Name = textBox3.Text;
item.price = textBox4.Text;
item.Category = comboBox2.Text;
Item_Manager _Manager = new Item_Manager();
_Manager.DeleteItem(item);
v();
}
