public FeedImage(uint photoId)
{
var storage = Storages.GetByFileId(photoId);
src = ServiceUrlPrefixes.CouldFront + storage.storage_path;
size = JsonConvert.DeserializeObject <FeedImageSize>(storage.@params);
}
/// <summary>
/// The is multiple data type.
/// </summary>
/// <param name="dataTypeId">
/// The data type id.
/// </param>
/// <param name="propertyEditorAlias"></param>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
private bool IsMultipleDataType(int dataTypeId, string propertyEditorAlias)
{
// GetPreValuesCollectionByDataTypeId is cached at repository level;
// still, the collection is deep-cloned so this is kinda expensive,
// better to cache here + trigger refresh in DataTypeCacheRefresher
return(Storages.GetOrAdd(dataTypeId, id =>
{
var preVals = _dataTypeService.GetPreValuesCollectionByDataTypeId(id).PreValuesAsDictionary;
if (preVals.ContainsKey("multiPicker"))
{
var preValue = preVals
.FirstOrDefault(x => string.Equals(x.Key, "multiPicker", StringComparison.InvariantCultureIgnoreCase))
.Value;
return preValue != null && preValue.Value.TryConvertTo <bool>().Result;
}
//in some odd cases, the pre-values in the db won't exist but their default pre-values contain this key so check there
var propertyEditor = PropertyEditorResolver.Current.GetByAlias(propertyEditorAlias);
if (propertyEditor != null)
{
var preValue = propertyEditor.DefaultPreValues
.FirstOrDefault(x => string.Equals(x.Key, "multiPicker", StringComparison.InvariantCultureIgnoreCase))
.Value;
return preValue != null && preValue.TryConvertTo <bool>().Result;
}
return false;
}));
}
public static List <StoreMoveAggregationEntity> AggregateStoreMove(CompositeFilterDescriptorCollection filters)
{
var lp = _query.LinqOP;
var brandIDs = VMGlobal.PoweredBrands.Select(o => o.ID);
var storemoveContext = lp.Search <BillStoreMove>(o => o.OrganizationID == VMGlobal.CurrentUser.OrganizationID);
FilterBillWithBrand(storemoveContext, filters, brandIDs);
var detailsContext = lp.GetDataContext <BillStoreMoveDetails>();
var productContext = lp.GetDataContext <ViewProduct>();
var data = from sm in storemoveContext
from details in detailsContext
where sm.ID == details.BillID
from product in productContext
where product.ProductID == details.ProductID //&& brandIDs.Contains(product.BrandID)
select new StoreMoveEntityForAggregation
{
ID = sm.ID,
ProductID = product.ProductID,
BrandID = product.BrandID,
Code = sm.Code,
CreateTime = sm.CreateTime.Date,
StorageIDIn = sm.StorageIDIn,
StorageIDOut = sm.StorageIDOut,
StyleCode = product.StyleCode,
Quantity = details.Quantity
};
var filtedData = (IQueryable <StoreMoveEntityForAggregation>)data.Where(filters);
var sum = filtedData.GroupBy(o => new { o.ProductID, o.StorageIDOut, o.StorageIDIn }).Select(g => new
{
Key = g.Key,
Quantity = g.Sum(o => o.Quantity)
}).ToList();
var pids = sum.Select(o => o.Key.ProductID).ToArray();
var products = _query.LinqOP.Search <ViewProduct>(o => pids.Contains(o.ProductID)).ToList();
var result = sum.Select(o =>
{
var product = products.First(p => p.ProductID == o.Key.ProductID);
return(new StoreMoveAggregationEntity
{
BYQID = product.BYQID,
ProductID = product.ProductID,
ProductCode = product.ProductCode,
StyleCode = product.StyleCode,
ColorID = product.ColorID,
SizeID = product.SizeID,
Quantity = o.Quantity,
OutStorageName = Storages.Find(s => s.ID == o.Key.StorageIDOut).Name,
InStorageName = Storages.Find(s => s.ID == o.Key.StorageIDIn).Name
});
}).ToList();
foreach (var r in result)
{
r.ColorCode = VMGlobal.Colors.Find(o => o.ID == r.ColorID).Code;
r.BrandID = VMGlobal.BYQs.Find(o => o.ID == r.BYQID).BrandID;
r.BrandCode = VMGlobal.PoweredBrands.Find(o => o.ID == r.BrandID).Code;
r.SizeName = VMGlobal.Sizes.Find(o => o.ID == r.SizeID).Name;
}
return(result);
}
public string GetVideoUrl(string remoteStoragePrefix)
{
switch (type)
{
case "1":
case "youtube":
return($"www.youtube.com/embed/{code}?wmode=opaque&autoplay=1");
case "3":
case "upload":
case "mydevice":
return($"{remoteStoragePrefix}{Storages.GetByFileId(file_id).storage_path}");
case "2":
case "vimeo":
return
($"player.vimeo.com/video/{code}?title=0&byline=0&portrait=0&wmode=opaque&autoplay=1");
case "4":
case "dailymotion":
return($"www.dailymotion.com/embed/video/{code}?wmode=opaque&autoplay=1");
case "6":
case "embedcode":
case "iframely":
return(string.IsNullOrEmpty(code) ? code : "");
case "fb":
Dictionary <string, string> data = JsonConvert.DeserializeObject <Dictionary <string, string> >(code);
return(data["video"]);
default:
return(string.Empty);
}
}
private void MoveNormal(Player player, byte fromSlot, byte toSlot, Storages toStorage, IStorage fromItemStorage, Item item, IStorage toItemStorage)
{
fromItemStorage.RemoveItem(item);
if (!toItemStorage.AddItem(toSlot, item))
{
fromItemStorage.AddItem(item);
player.ViewPlugIns.GetPlugIn <IItemMoveFailedPlugIn>()?.ItemMoveFailed(item);
return;
}
player.ViewPlugIns.GetPlugIn <Views.Inventory.IItemMovedPlugIn>()?.ItemMoved(item, toSlot, toStorage);
var isTradeOngoing = player.PlayerState.CurrentState == PlayerState.TradeOpened ||
player.PlayerState.CurrentState == PlayerState.TradeButtonPressed;
var isItemMovedToOrFromTrade = toItemStorage == player.TemporaryStorage || fromItemStorage == player.TemporaryStorage;
if (isTradeOngoing && isItemMovedToOrFromTrade && player.TradingPartner is Player tradingPartner)
{
// When Trading, send update to Trading-Partner
if (fromItemStorage == player.TemporaryStorage)
{
tradingPartner.ViewPlugIns.GetPlugIn <ITradeItemDisappearPlugIn>()?.TradeItemDisappear(fromSlot, item);
}
if (toItemStorage == player.TemporaryStorage)
{
tradingPartner.ViewPlugIns.GetPlugIn <ITradeItemAppearPlugIn>()?.TradeItemAppear(toSlot, item);
}
}
}
/// <summary>
/// Moves the item.
/// </summary>
/// <param name="player">The player.</param>
/// <param name="fromSlot">From slot.</param>
/// <param name="fromStorage">From storage.</param>
/// <param name="toSlot">To slot.</param>
/// <param name="toStorage">To storage.</param>
public void MoveItem(Player player, byte fromSlot, Storages fromStorage, byte toSlot, Storages toStorage)
{
var fromStorageInfo = this.GetStorageInfo(player, fromStorage);
var fromItemStorage = fromStorageInfo?.Storage;
var item = fromItemStorage?.GetItem(fromSlot);
if (item is null)
{
// Item not found
player.ViewPlugIns.GetPlugIn <IItemMoveFailedPlugIn>()?.ItemMoveFailed(null);
return;
}
var toStorageInfo = this.GetStorageInfo(player, toStorage);
var toItemStorage = toStorageInfo?.Storage;
var movement = this.CanMove(player, item, toSlot, fromSlot, toStorageInfo, fromStorageInfo);
if (movement != Movement.None)
{
var cancelEventArgs = new CancelEventArgs();
player.GameContext.PlugInManager.GetPlugInPoint <IItemMovingPlugIn>()?.ItemMoving(player, item, fromStorage, toSlot, cancelEventArgs);
if (cancelEventArgs.Cancel)
{
movement = Movement.None;
}
}
switch (movement)
{
case Movement.Normal:
this.MoveNormal(player, fromSlot, toSlot, toStorage, fromItemStorage !, item, toItemStorage !);
break;
case Movement.PartiallyStack when toItemStorage?.GetItem(toSlot) is
{
}
targetItem:
this.PartiallyStack(player, item, targetItem);
break;
case Movement.CompleteStack when toItemStorage?.GetItem(toSlot) is
{
}
targetItem:
this.FullStack(player, item, targetItem);
break;
default:
player.ViewPlugIns.GetPlugIn <IItemMoveFailedPlugIn>()?.ItemMoveFailed(item);
break;
}
if (movement != Movement.None)
{
player.GameContext.PlugInManager.GetPlugInPoint <PlugIns.IItemMovedPlugIn>()?.ItemMoved(player, item);
}
}
public TransactionsViewModel(Storages storages)
{
_storages = storages;
Accounts = new ObservableCollection <IAccount>(_storages.AccountStorage.GetAllAccounts());
_activeAccount = Accounts.FirstOrDefault();
RefreshTransactionByAccount();
}
/// <summary>
/// 選択されたアイテムの展開/折りたたみ状態を設定する
/// </summary>
/// <param name="param"></param>
private void SetSelectedExpanded(bool?param)
{
foreach (var item in Storages.Where(x => x.IsSelected))
{
item.IsExpanded = param == true;
}
}
public async Task <ActionResult <Storages> > PostStorages(Storages storages)
{
_context.Storages.Add(storages);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetStorages", new { id = storages.StorageId }, storages));
}
public GlobalSettings()
{
var accountFactory = new RegularAccountFactory();
var categoryFactory = new RegularCategoryFactory();
var transactionFactory = new RegularTransactionFactory();
var quickTransactionFactory = new RegularQuickTransactionFactory();
var accountStorage = new CachedAccountStorage(
new SqLiteAccountStorage(accountFactory));
var categoryStorage = new CachedCategoryStorage(
new SqLiteCategoryStorage(categoryFactory));
var transactionStorage = new CachedTransactionStorage(
new SqLiteTransactionStorage(transactionFactory, accountStorage, categoryStorage));
Storages = new Storages
{
AccountStorage = accountStorage,
CategoryStorage = categoryStorage,
TransactionStorage = transactionStorage,
BarCodeStorage = new CachedBarCodeStorage(
new SqLiteBarCodeStorage(new BarCodeFactory(), transactionStorage)),
QuickTransactionStorage = new CachedQuickTransactionStorage(
new SqLiteQuickTransactionStorage(quickTransactionFactory, accountStorage, categoryStorage))
};
}
public async Task <IActionResult> PutStorages(int id, Storages storages)
{
if (id != storages.StorageId)
{
return(BadRequest());
}
_context.Entry(storages).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!StoragesExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void Commit()
{
#if MultiThread
if (!this.bWrite)
{
throw new Exception("Subthread Commit Error!");
}
#endif
Snap.Commit();
Blocks.Commit();
Heights.Commit();
Transfers.Commit();
Accounts.Commit();
Contracts.Commit();
Storages.Commit();
BlockChains.Commit();
StoragesMap.Commit();
ABC.Commit();
List.Commit();
Queue.Commit();
if (Undos != null)
{
batch?.Put($"Undos___{Undos.height}", JsonHelper.ToJson(new DbCache <DbUndo> .Slice()
{
obj = Undos
}));
batch?.Put("UndoHeight", Undos.height.ToString());
}
db.Write(batch, new WriteOptions {
Sync = true
});
}
public TransactionCreateViewModel(Storages storages, IAccount activeAccount) : base(storages)
{
if (activeAccount != null)
{
Account = Accounts.FirstOrDefault(x => x.Id == activeAccount.Id);
}
}
public void Commit()
{
Snap.Commit();
Blocks.Commit();
Heights.Commit();
Transfers.Commit();
Accounts.Commit();
Contracts.Commit();
Storages.Commit();
BlockChains.Commit();
StoragesAccount.Commit();
ABC.Commit();
List.Commit();
if (Undos != null)
{
batch?.Put($"Undos___{Undos.height}", JsonHelper.ToJson(new DbCache <DbUndo> .Slice()
{
obj = Undos
}));
batch.Put("UndoHeight", Undos.height.ToString());
}
db.Write(batch, new WriteOptions {
Sync = true
});
}
//private void ListUnboxedSpecimens(int colId)
//{
// SpecimenManagerDa da = new SpecimenManagerDa();
// DataTable dt = da.GetUnboxedSpecimensByCollectionId(colId);
// this.unboxedSpecList.DataSource = dt.DefaultView;
// this.unboxedSpecList.DataBind();
//}
private void BindOriginSelectBoxes()
{
if (QueryBoxId > 0)
{
SpecimenManagerDa da = new SpecimenManagerDa();
DataSet resultsDataSet = da.GetBoxAndAncestors(QueryBoxId);
SpecimenBox box = new SpecimenBox();
box.Get(QueryBoxId);
DataTable boxesDT = resultsDataSet.Tables[0];
Boxes.DataSource = boxesDT;
Boxes.DataBind();
Boxes.Value = box[SpecimenBox.BoxId].ToString();
DataTable containersDT = resultsDataSet.Tables[1];
Containers.DataSource = containersDT;
Containers.DataBind();
Containers.Value = boxesDT.Rows[0][SpecimenBox.ContainerId].ToString();
DataTable storagesDT = resultsDataSet.Tables[2];
Storages.DataSource = storagesDT;
Storages.DataBind();
Storages.Value = containersDT.Rows[0][SpecimenContainer.StorageId].ToString();
string siteId = resultsDataSet.Tables[3].Rows[0][SpecimenSite.SiteId].ToString();
Sites.Value = siteId;
}
}
private StorageInfo GetStorageInfo(Player player, Storages storageType)
{
StorageInfo result = null;
switch (storageType)
{
case Storages.Inventory:
result = new StorageInfo
{
Rows = InventoryRows,
StartIndex = EquippableSlotsCount,
EndIndex = (byte)(EquippableSlotsCount + GetInventorySize(player)),
Storage = player.Inventory
};
break;
case Storages.PersonalStore:
result = new StorageInfo
{
Rows = StoreRows,
StartIndex = FirstStoreItemSlotIndex,
EndIndex = FirstStoreItemSlotIndex + StoreSize,
Storage = player.ShopStorage
};
break;
case Storages.Vault:
result = new StorageInfo
{
Rows = WarehouseRows,
EndIndex = WarehouseSize,
Storage = player.Vault,
StartIndex = 0
};
break;
case Storages.Trade:
result = new StorageInfo
{
Storage = player.TemporaryStorage,
Rows = TemporaryStorageRows,
EndIndex = TemporaryStorageSize,
StartIndex = 0
};
break;
default: // CM
result = new StorageInfo
{
Storage = player.TemporaryStorage,
Rows = TemporaryStorageRows,
EndIndex = TemporaryStorageSize,
StartIndex = 0
};
break;
}
return(result);
}
/// <summary>
/// Load de la página
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void Page_Load(object sender, EventArgs e)
{
/// Verificar que no se haya vencido la session
if (Session[Constants.NameSessionUser] == null)
{
Utilities.logout(Page.Session, Page.Response);
}
else
{
_user = (Users)Session[Constants.NameSessionUser];
}
/// Agregar el evento que manejara el enter dado desde la caja de texto
txtCodigoArticulo.Attributes.Add("onkeypress", "KeyboardHandler('" + btFindArticle.ClientID + "')");
/// Agregar control de seleccion de texto
txtCodigoArticulo.Attributes.Add("onfocus", "SetSelected('" + txtCodigoArticulo.ClientID + "');");
if (!IsPostBack)
{
if ((_user._usu_tip_id == "02"))
{
Utilities.logout(Page.Session, Page.Response);
}
else
{
this.formForEmployee();
}
//if (_user._usv_employee)
// this.formForEmployee();
//else Utilities.logout(Page.Session, Page.Response);
if (!_user._usn_userid.Equals("%%"))
{
//lblWhoIs.Text = " ( " + _user._usv_warehouse_name + " ) - " + _user._usv_name;
lblWhoIs.Text = " ( " + _user._nombre + " ) ";// - " + _user._usv_name;
}
else
{
lblWhoIs.Text = " ( Usuario Nal. ) - " + _user._usv_name;
}
///
DataTable dt = this.createStructureDataTable();
Session[_nameSessionArtsRet] = new DataView(dt);
///
DataSet dtStorages = Storages.getStorageByWereHouse();
dwStorages.DataSource = dtStorages;
dwStorages.DataBind();
dwStorages.SelectedValue = "11";
dwStorages.Enabled = false;
}
}
public virtual void CheckPossibilityToAccept()
{
ValidationUtils.Assert(State == AccountingPriceListState.New,
String.Format("Невозможно провести реестр со статусом {0}", State.GetDisplayName()));
ValidationUtils.Assert(Storages.Any(), "Невозможно провести реестр цен без мест хранения.");
ValidationUtils.Assert(ArticlePrices.Any(), "Невозможно провести реестр цен без товаров.");
}
private StorageInfo?GetStorageInfo(Player player, Storages storageType)
{
StorageInfo?result;
switch (storageType)
{
case Storages.Inventory when player.Inventory is not null:
result = new StorageInfo(
player.Inventory,
InventoryRows,
EquippableSlotsCount,
(byte)(EquippableSlotsCount + GetInventorySize(player)));
break;
case Storages.PersonalStore when player.ShopStorage is not null:
result = new StorageInfo(
player.ShopStorage,
StoreRows,
FirstStoreItemSlotIndex,
(byte)(FirstStoreItemSlotIndex + StoreSize));
break;
case Storages.Vault when player.Vault is not null:
result = new StorageInfo(player.Vault, WarehouseRows, 0, WarehouseSize);
break;
case Storages.Trade:
case Storages.ChaosMachine:
case Storages.PetTrainer:
case Storages.Refinery:
case Storages.Smelting:
case Storages.ItemRestore:
case Storages.ChaosCardMaster:
case Storages.CherryBlossomSpirit:
case Storages.SeedCrafting:
case Storages.SeedSphereCrafting:
case Storages.SeedMountCrafting:
case Storages.SeedUnmountCrafting:
if (player.TemporaryStorage is not null)
{
result = new StorageInfo(player.TemporaryStorage, TemporaryStorageRows, 0, TemporaryStorageSize);
}
else
{
result = null;
}
break;
default:
result = null;
player.Logger.LogError($"Moving to {storageType} is not implemented.");
break;
}
return(result);
}
public virtual void Commit()
{
Blocks.Commit();
Transactions.Commit();
Storages.Commit();
HeaderHashList.Commit();
BlockHashIndex.Commit();
HeaderHashIndex.Commit();
}
public virtual void SetDocumentStorage(Sungero.Docflow.Server.AsyncHandlerInvokeArgs.SetDocumentStorageInvokeArgs args)
{
int documentId = args.DocumentId;
int storageId = args.StorageId;
Logger.DebugFormat("SetDocumentStorage: start set storage to document {0}.", documentId);
var document = OfficialDocuments.GetAll(d => d.Id == documentId).FirstOrDefault();
if (document == null)
{
Logger.DebugFormat("SetDocumentStorage: not found document with id {0}.", documentId);
return;
}
var storage = Storages.GetAll(s => s.Id == storageId).FirstOrDefault();
if (storage == null)
{
Logger.DebugFormat("SetDocumentStorage: not found storage with id {0}.", storageId);
return;
}
if (Locks.GetLockInfo(document).IsLockedByOther)
{
Logger.DebugFormat("SetDocumentStorage: cannot change storage, document {0} is locked.", documentId);
args.Retry = true;
return;
}
try
{
foreach (var version in document.Versions.Where(v => !Equals(v.Body.Storage, storage) || !Equals(v.PublicBody.Storage, storage)))
{
if (!Equals(version.Body.Storage, storage))
{
version.Body.SetStorage(storage);
}
if (!Equals(version.PublicBody.Storage, storage))
{
version.PublicBody.SetStorage(storage);
}
}
document.Storage = storage;
((Domain.Shared.IExtendedEntity)document).Params[Docflow.PublicConstants.OfficialDocument.DontUpdateModified] = true;
document.Save();
}
catch (Exception ex)
{
Logger.Error("SetDocumentStorage: cannot change storage.", ex);
args.Retry = true;
return;
}
Logger.DebugFormat("SetDocumentStorage: set storage to document {0} successfully.", documentId);
}
public FeedReaction(Reaction reaction, uint count)
{
caption = reaction.title;
if (count > 0)
{
reaction_count = count;
}
reactionicon_id = reaction.reactionicon_id;
reaction_image_icon = ServiceUrlPrefixes.CouldFront + Storages.GetByFileId(reaction.photo_id).storage_path;
}
public LikeBy(Like like)
{
user_id = like.poster_id;
var user = Users.GetById((uint)user_id);
displayname = user.displayname;
image_profile = ServiceUrlPrefixes.CouldFront + Storages.GetByFileId((uint)user.photo_id).storage_path;
reaction_image_icon = like.reaction;
image = image_normal = image_icon = image_profile;
}
/// <summary>
/// リソースを開放
/// </summary>
public void Dispose()
{
_Model.PropertyChanged -= Model_PropertyChanged;
LocalizeDictionary.Instance.PropertyChanged -= Instance_PropertyChanged;
_Model.Dispose();
Summary.Dispose();
Modules.Dispose();
Products.Dispose();
Resources.Dispose();
Storages.Dispose();
}
public void Dispose()
{
if (_disposed)
{
return;
}
_disposed = true;
_itemsWorker?.Stop(true);
_itemsWorker?.Clear();
Storages?.Clear();
}
/// <summary>
/// Converts the enum value into the enum type used in the packets.
/// </summary>
/// <param name="storage">The enum value.</param>
/// <returns>The converted value.</returns>
public static ItemStorageKind Convert(this Storages storage)
{
return(storage switch
{
Storages.Inventory => ItemStorageKind.Inventory,
Storages.ChaosMachine => ItemStorageKind.ChaosMachine,
Storages.PersonalStore => ItemStorageKind.PlayerShop,
Storages.Trade => ItemStorageKind.Trade,
Storages.Vault => ItemStorageKind.Vault,
_ => throw new NotImplementedException($"Unhandled case {storage}."),
});
private async Task DeleteStorage(StorageViewModel storageViewModel)
{
if (await this.pageService.DisplayAlert("Warning", $"Are you sure you want to delete {storageViewModel}?", "Yes", "No"))
{
Storages.Remove(storageViewModel);
var storage = await this.storageStore.GetStorage(storageViewModel.Id);
await this.storageStore.DeleteStorage(storage);
}
}
//private Visibility _isChildTransactionVisible;
public TransactionViewModelBase(Storages storages)
{
_storages = storages ?? throw new ArgumentException("storages mustn't NULL");
Accounts = _storages.AccountStorage.GetAllAccounts();
Categories = _storages.CategoryStorage.MakeFlatCategoryTree();
Transactions = _storages.TransactionStorage.GetAllTransactions();
Timestamp = DateTime.Now;
Date = new DateTimeOffset(Timestamp);
Time = Timestamp.TimeOfDay;
ChildrenTransactions = new ObservableCollection <ITransaction>();
}
/// <inheritdoc/>
public void ItemMoved(Item item, byte toSlot, Storages storage)
{
using (var writer = this.connection.StartSafeWrite(0xC3, 0x11))
{
var itemMoved = writer.Span;
itemMoved[2] = 0x24;
itemMoved[3] = storage == Storages.PersonalStore ? (byte)0 : (byte)storage;
itemMoved[4] = toSlot;
this.itemSerializer.SerializeItem(itemMoved.Slice(5), item);
writer.Commit();
}
}
public EditQuickTransactionViewModel(Storages storages, IQuickTransaction quickTransaction)
{
_storages = storages;
_quickTransaction = quickTransaction;
Account = Accounts.FirstOrDefault(x => x.Id == quickTransaction?.Account?.Id);
Category = Categories.FirstOrDefault(x => x.Id == quickTransaction?.Category?.Id);
Name = quickTransaction.Name;
Total = quickTransaction.Total;
Weight = quickTransaction.Weight;
AskForWeight = quickTransaction.AskForWeight;
AskForTotal = quickTransaction.AskForTotal;
}
