public void Initialize(CatalogItemModel virtualItem, IStoreDemoImplementation demoImplementation)
{
_demoImplementation = demoImplementation;
var text = "";
var virtualPrice = virtualItem.VirtualPrice;
if (virtualPrice != null)
{
var valuePair = virtualPrice.Value;
text = FormatVirtualCurrencyBuyButtonText(valuePair.Key, valuePair.Value.ToString());
}
else
{
var realPrice = virtualItem.RealPrice;
if (realPrice != null)
{
var valuePair = realPrice.Value;
var currency = RegionalCurrency.GetCurrencySymbol(valuePair.Key);
text = FormatBuyButtonText(currency, valuePair.Value.ToString("F2"));
}
}
buyButton.Text = text;
itemName.text = virtualItem.Name;
itemDescription.text = virtualItem.Description;
gameObject.name = "Item_" + virtualItem.Name.Replace(" ", "");
ImageLoader.Instance.GetImageAsync(virtualItem.ImageUrl, LoadImageCallback);
AttachBuyButtonHandler(virtualItem);
}
public void SaveItem(CatalogItemModel model)
{
var item = model.Source;
if (model.Picture != null)
{
string extension = ContentTypes.GetExtensionFromContentType(model.PictureContentType);
item.PictureFileName = $"{DateTime.UtcNow.Ticks}{extension}";
}
var provider = new SqlServerProvider(ConnectionString);
if (item.Id == 0)
{
// New
item.Id = GenerateId();
provider.InsertCatalogItem(item.Id, item.Name, item.Description, item.PictureFileName, item.Price, item.CatalogTypeId, item.CatalogBrandId, item.IsDisabled);
provider.InsertCatalogImage(item.Id, model.Picture);
}
else
{
// Update
if (model.Picture != null)
{
provider.UpdateCatalogImage(item.Id, model.Picture);
}
provider.UpdateCatalogItem(item.Id, item.Name, item.Description, item.PictureFileName, item.Price, item.CatalogTypeId, item.CatalogBrandId, item.IsDisabled);
}
}
private void PopulateImage(CatalogItemModel model, string pictureFileName)
{
// TODO: Default picture
model.PictureUri = null;
if (pictureFileName != null)
{
var storage = new FileStorage("Images");
if (storage.FileExsits(pictureFileName))
{
model.PictureUri = GetPictureUri(pictureFileName);
}
else
{
var provider = new SqlServerProvider(ConnectionString);
var dataTable = provider.GetCatalogImage(model.Id);
if (dataTable.Rows.Count > 0)
{
var dataRow = dataTable.Rows[0];
var picture = dataRow["Picture"] as byte[];
if (picture != null)
{
storage.WriteBytes(pictureFileName, picture);
model.PictureUri = GetPictureUri(pictureFileName);
}
}
}
}
}
public async Task SaveItemAsync(CatalogItemModel item)
{
var picture = item.Picture;
var contentType = item.PictureContentType;
item.Picture = null;
using (var cli = new WebApiClient(BaseAddressUri))
{
if (item.Id == 0)
{
// Create (POST)
var record = await cli.PostAsync <CatalogItem>("api/v1/catalog/items", item.Source);
item = new CatalogItemModel(record);
}
else
{
// Update (PUT)
await cli.PutAsync <string>("api/v1/catalog/items", item.Source);
}
if (picture != null)
{
using (var stream = new MemoryStream(picture))
{
await cli.PutStreamAsync($"api/v1/catalog/items/{item.Id}/pic", stream, contentType);
}
}
}
}
public async Task DeleteItemAsync(CatalogItemModel item)
{
using (var cli = new WebApiClient(BaseAddressUri))
{
await cli.DeleteAsync($"api/v1/catalog/{item.Id}");
}
}
public void GetInventoryItems([NotNull] Action <List <InventoryItemModel> > onSuccess, [CanBeNull] Action <Error> onError = null)
{
StartCoroutine(InventoryRequestCoroutine(inventory =>
{
onSuccess?.Invoke(inventory.Inventory.Select(i =>
{
CatalogItemModel catalogItem = UserCatalog.Instance.VirtualItems.First(c => c.Sku.Equals(i.ItemId));
if (catalogItem == null)
{
Debug.LogWarning($"Can not create inventory item `{i.ItemId}`, because it not found in catalog");
return(null);
}
return(new InventoryItemModel
{
Sku = i.ItemId,
Name = i.DisplayName,
RemainingUses = i.RemainingUses,
InstanceId = i.ItemInstanceId,
Description = catalogItem.Description,
ImageUrl = catalogItem.ImageUrl,
IsConsumable = catalogItem.IsConsumable
});
}).ToList());
}, onError));
}
public void AddItem(CatalogItemModel virtualItemInformation)
{
ItemUI item = Instantiate(itemPrefab, itemParent).GetComponent <ItemUI>();
item.Initialize(virtualItemInformation, _demoImplementation);
_items.Add(item);
}
public void GetVirtualCurrencyBalance([NotNull] Action <List <VirtualCurrencyBalanceModel> > onSuccess, [CanBeNull] Action <Error> onError = null)
{
StartCoroutine(InventoryRequestCoroutine(inventory =>
{
onSuccess?.Invoke(inventory.VirtualCurrency.Select(pair =>
{
string vcSku = pair.Key;
uint amount = pair.Value;
CatalogItemModel catalogItem = UserCatalog.Instance.Currencies.First(c => c.CurrencySku.Equals(vcSku));
if (catalogItem == null)
{
Debug.LogWarning($"Can not create virtual currency balance `{vcSku}`, because this currency not found in catalog");
return(null);
}
return(new VirtualCurrencyBalanceModel
{
Sku = vcSku,
Name = catalogItem.Name,
Description = catalogItem.Description,
ImageUrl = catalogItem.ImageUrl,
IsConsumable = catalogItem.IsConsumable,
Amount = amount
});
}).ToList());
}, onError));
}
private void AddBarItem(CatalogItemModel item)
{
if (!BarItems.Contains(item))
{
BarItems.Add(item);
}
}
private void RemoveBarItem(CatalogItemModel item)
{
if (BarItems.Contains(item))
{
BarItems.Remove(item);
}
}
public MovimientoGridSalidaOfficeViewModel(USUARIO u)
{
try
{
IDataMapper dataMapper = new SolicitanteDataMapper();
IDataMapper dataMapper2 = new AlmacenDataMapper();
IDataMapper dataMapper3 = new ProveedorDataMapper();
IDataMapper dataMapper4 = new ClienteDataMapper();
IDataMapper dataMapper5 = new TipoPedimentoDataMapper();
this._catalogSolicitanteModel = new CatalogSolicitanteModel(dataMapper);
this._catalogMovimientoModel = new CatalogMovimientoModel(new MovimientoDataMapper(), "Entregado");
TIPO_MOVIMIENTO mov = new TIPO_MOVIMIENTO();
//mov.UNID_TIPO_MOVIMIENTO = 1;
//this._movimientoGridModel.TipoMovimiento = mov;
this._itemModel = new CatalogItemModel(new ItemDataMapper());
this._catalogAlmacenModel = new CatalogAlmacenModel(dataMapper2);
this._catalogAlmacenProcedenciaModel = new CatalogAlmacenModel(dataMapper2);
this._catalogProveedorProcedenciaModel = new CatalogProveedorModel(dataMapper3);
this._catalogClienteProcedenciaModel = new CatalogClienteModel(dataMapper4);
this._catalogTipoPedimentoModel = new CatalogTipoPedimentoModel(dataMapper5);
this.ActualUser = u;
}
catch (ArgumentException a)
{
;
}
catch (Exception ex)
{
throw ex;
}
}
private async Task PopulateImageAsync(CatalogItemModel model, string pictureFileName)
{
// TODO: Default picture
model.PictureUri = null;
if (pictureFileName != null)
{
var folder = await ApplicationData.Current.LocalFolder.CreateFolderAsync("Images", CreationCollisionOption.OpenIfExists);
var storage = new FileStorage(folder);
if (await storage.FileExsits(pictureFileName))
{
model.PictureUri = GetPictureUri(pictureFileName);
}
else
{
var provider = new SqlServerProvider(ConnectionString);
var dataTable = provider.GetCatalogImage(model.Id);
if (dataTable.Rows.Count > 0)
{
var dataRow = dataTable.Rows[0];
var picture = dataRow["Picture"] as byte[];
if (picture != null)
{
await storage.WriteBytes(pictureFileName, picture);
model.PictureUri = GetPictureUri(pictureFileName);
}
}
}
}
}
public List <string> GetCatalogGroupsByItem(CatalogItemModel item)
{
return(new List <string>
{
item.IsVirtualCurrency() ? CURRENCY_GROUP : ITEMS_GROUP
});
}
public CatalogItemViewModel(TraspasoStockViewModel _traspasoStockViewModel)
{
IDataMapper dataMapper = new ItemDataMapper();
this._catalogItemModel = new CatalogItemModel(dataMapper);
this._traspasoStockViewModel = _traspasoStockViewModel;
}
public Task DeleteItemAsync(CatalogItemModel model)
{
return(Task.Run(() =>
{
var provider = new SqlServerProvider(ConnectionString);
provider.DeleteCatalogItem(model.Id);
}));
}
public CatalogItemViewModel(SalidaRentaViewModel _salidaRentaViewModel)
{
IDataMapper dataMapper = new ItemDataMapper();
this._catalogItemModel = new CatalogItemModel(dataMapper);
this._salidaRentaViewModel = _salidaRentaViewModel;
}
public CatalogItemViewModel(SalidaConfiguracionViewModel _salidaConfiguracionViewModel)
{
IDataMapper dataMapper = new ItemDataMapper();
this._catalogItemModel = new CatalogItemModel(dataMapper);
this._salidaConfiguracionViewModel = _salidaConfiguracionViewModel;
}
private IEnumerator VirtualCurrencyPurchaseFinished(CatalogItemModel virtualItem)
{
var refreshDelay = virtualItem.IsVirtualCurrency() ? PLAYFAB_VIRTUAL_CURRENCY_ACCRUAL_TIMEOUT : 0.0F;
yield return(new WaitForSeconds(refreshDelay));
UserInventory.Instance.Refresh();
}
public void loadItemsTest()
{
IDataMapper dataMapper = new ItemDataMapper();
CatalogItemModel target = new CatalogItemModel(dataMapper); // TODO: Inicializar en un valor adecuado
target.loadItems();
Assert.Inconclusive("Un método que no devuelve ningún valor no se puede comprobar.");
}
public CatalogItemViewModel(EntradaDesinstalacionViewModel _entradaDesinstalacionViewModel)
{
IDataMapper dataMapper = new ItemDataMapper();
this._catalogItemModel = new CatalogItemModel(dataMapper);
this._entradaDesinstalacionViewModel = _entradaDesinstalacionViewModel;
}
public CatalogItemViewModel(EntradaPrestamoViewModel _entradaPrestamoViewModel)
{
IDataMapper dataMapper = new ItemDataMapper();
this._catalogItemModel = new CatalogItemModel(dataMapper);
this._entradaPrestamoViewModel = _entradaPrestamoViewModel;
}
/// <summary>
/// Сохранение записи
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public ActionResult Save(CatalogItemModel model)
{
/*
* Нужно выводить информацию при ошибках в серверной валидации. Сейчас почему-то не выводится. Поэтому серверная валидация убрана.
* if (!ModelState.IsValid)
* {
* if (model.InPopUp)
* {
* return Json(new { error = SR.T("Не заполнены все обязательные поля") }, JsonRequestBehavior.AllowGet);
* }
* Notifier.Information(SR.T("Не заполнены все обязательные поля"));
* var template = "Add";
* return View(template, model);
* }
*/
var entityType = IMetadataRuntimeService.GetTypeByUid(model.TypeUid);
var manager = ModelHelper.GetEntityManager(entityType);
try
{
manager.Save(model.Entity);
}
catch (Exception ex)
{
Locator.GetServiceNotNull <IUnitOfWorkManager>().RollbackCurrent("");
Notifier.Error(ex.InnerException != null && !string.IsNullOrEmpty(ex.InnerException.Message) ? ex.InnerException.Message : ex.Message);
return(!IsCreatorRequest() ? View("Add", model) : CreatorJson(model.Entity, ex.Message));
}
if (IsCreatorRequest())
{
return(CreatorJson(model.Entity));
}
if (model.InPopUp)
{
return(Json(new { model.Continue }, JsonRequestBehavior.AllowGet));
}
if (!string.IsNullOrEmpty(model.BackUrl))
{
var filter = InterfaceActivator.Create <IDeptTrans_CatalogFilter>();
var entityType1 = new ReferenceOnEntityType {
TypeUid = model.TypeUid
};
filter.Spravochnik = entityType1;
//filter.TypeUidSpravochnika = model.TypeUid;
var listMyEntity = EntityManager <IDeptTrans_Catalog> .Instance.Find(filter, null);
if (listMyEntity.Any())
{
var newUrl = GenerateViewItemUrl(model.TypeUid, model.Entity.GetId(), null, null);
return(Redirect(newUrl));
}
else
{
return(Redirect(model.BackUrl));
}
}
return(RedirectToAction("View", new { area = CommonAreaRegistration.AREA_NAME, uid = model.TypeUid }));
}
private void OnItemClick(CatalogItemModel item)
{
if (SelectionMode == ListViewSelectionMode.None)
{
ItemsControl.PrepareConnectedAnimation("ItemSelected", item, "imageContainer");
ShellViewModel.NavigationService.Navigate(typeof(ItemDetailViewModel).FullName, new ItemDetailState(item));
State.SelectedItemId = item.Id;
}
}
private InventoryItemModel GetInventoryItemBy(CatalogItemModel item)
{
string json = item.SerializeToJson();
InventoryItemModel inventoryItemModel = json.DeserializeTo <InventoryItemModel>();
inventoryItemModel.RemainingUses = 1;
inventoryItemModel.InstanceId = null;
return(inventoryItemModel);
}
/// <summary>
/// Buys a single item with real money.
/// </summary>
/// <param name="virtualItem">Entity of the item from the title catalog.</param>
/// <param name="onSuccess">Success operation callback.</param>
/// <param name="onError">Failed operation callback.</param>
public void PurchasePlayfabItemForRealMoney(CatalogItemModel virtualItem, [NotNull] Action <string> onSuccess,
[CanBeNull] Action <Error> onError = null)
{
PlayfabApi.Purchases.ItemPurchase(virtualItem.Sku, response =>
{
Payments.PaymentsHelper.OpenPurchaseByAccessToken(response.ProviderToken, XsollaSettings.IsSandbox);
ProcessOrder(response.OrderId, () => onSuccess?.Invoke(virtualItem.Sku));
}, onError);
}
public void CatalogItemModelConstructorTest()
{
IDataMapper dataMapper = new ItemDataMapper(); // TODO: Inicializar en un valor adecuado
CatalogItemModel target = new CatalogItemModel(dataMapper);
target.Serie = "123456";
target.loadItems();
Assert.Inconclusive("TODO: Implementar código para comprobar el destino");
}
public SalidaCorrectivoViewModel(MovimientoGridSalidaCorrectivoViewModel salida)
{
try
{
IDataMapper dataMapper = new SolicitanteDataMapper();
IDataMapper dataMapper2 = new AlmacenDataMapper();
IDataMapper dataMapper3 = new ProveedorDataMapper();
IDataMapper dataMapper4 = new ClienteDataMapper();
IDataMapper dataMapper5 = new ServicioDataMapper();
IDataMapper dataMapper6 = new TipoPedimentoDataMapper();
IDataMapper dataMapper7 = new TransporteDataMapper();
IDataMapper dataMapper8 = new TecnicoDataMapper();
IDataMapper datamapper11 = new EmpresaDataMapper();
this._catalogEmpresaModel = new CatalogEmpresaModel(datamapper11);
this._catalogSolicitanteModel = new CatalogSolicitanteModel(dataMapper);
this._movimientoModel = new MovimientoSalidasModel(new MovimientoDataMapper(), salida.ActualUser);
TIPO_MOVIMIENTO mov = new TIPO_MOVIMIENTO();
mov.UNID_TIPO_MOVIMIENTO = 14;
this._movimientoSalida = salida;
this._movimientoModel.TipoMovimiento = mov;
this._movimientoModel.PropertyChanged += OnPropertyChanged2;
this._itemModel = new CatalogItemModel(new ItemDataMapper());
this._catalogAlmacenDestinoModel = new CatalogAlmacenModel(dataMapper2);
this._catalogAlmacenProcedenciaModel = new CatalogAlmacenModel(dataMapper2);
this._catalogProveedorDestinoModel = new CatalogProveedorModel(dataMapper3);
this._catalogClienteDestinoModel = new CatalogClienteModel(dataMapper4);
this._catalogServicioModel = new CatalogServicioModel(dataMapper5);
this._catalogTipoPedimentoModel = new CatalogTipoPedimentoModel(dataMapper6);
this._catalogTransporteModel = new CatalogTransporteModel(dataMapper7);
this._catalogClienteModel = new CatalogClienteModel(dataMapper4);
this._catalogTecnicoModel = new CatalogTecnicoModel(dataMapper8);
//Asignaciones especiales para los combos
this._movimientoModel.Empresa = _catalogEmpresaModel.Empresa[0];
this._movimientoModel.Solicitante = _catalogSolicitanteModel.Solicitante[0];
//this._movimientoModel.Servicio = _catalogServicioModel.Servicio[0];
//this._movimientoModel.Cliente = _catalogClienteModel.Cliente[0];
this._movimientoModel.AlmacenProcedencia = _catalogAlmacenProcedenciaModel.Almacen[0];
this._movimientoModel.Tecnico = _movimientoModel.Tecnicos[0];
this._movimientoModel.AlmacenDestino = _catalogAlmacenDestinoModel.Almacen[0];
this._movimientoModel.ClienteDestino = _catalogClienteDestinoModel.Cliente[0];
this._movimientoModel.ProveedorDestino = _catalogProveedorDestinoModel.Proveedor[0];
this._movimientoModel.Transporte = _catalogTransporteModel.Transporte[0];
this._IsEnabled = true;
}
catch (ArgumentException a)
{
;
}
catch (Exception ex)
{
throw ex;
}
}
public void PurchaseForVirtualCurrency(CatalogItemModel item,
[CanBeNull] Action <CatalogItemModel> onSuccess = null, [CanBeNull] Action <Error> onError = null)
{
StoreDemoPopup.ShowConfirm(() =>
PurchaseHelper.Instance.PurchasePlayfabItemForVirtualCurrency(item, purchasedItem =>
{
StartCoroutine(VirtualCurrencyPurchaseFinished(purchasedItem));
StoreDemoPopup.ShowSuccess($"You have purchased `{purchasedItem.Name}`!");
onSuccess?.Invoke(item);
}, GetErrorCallback(onError)));
}
public void PurchaseForRealMoney(CatalogItemModel item, [CanBeNull] Action <CatalogItemModel> onSuccess = null,
[CanBeNull] Action <Error> onError = null)
{
PurchaseHelper.Instance.PurchasePlayfabItemForRealMoney(item, _ =>
{
UserInventory.Instance.Refresh();
StoreDemoPopup.ShowSuccess();
Destroy(BrowserHelper.Instance);
onSuccess?.Invoke(item);
}, GetErrorCallback(onError));
}
private void AttachBuyButtonHandler(CatalogItemModel virtualItem)
{
if (virtualItem.VirtualPrice != null)
{
buyButton.onClick = () => _demoImplementation.PurchaseForVirtualCurrency(virtualItem);
}
else
{
buyButton.onClick = () => _demoImplementation.PurchaseForRealMoney(virtualItem);
}
}
