static ProxyTestHelper()
{
_person = new Person(PersonId);
_business = new Business(BusinessId);
_location = new Location(LocationId);
_phone = new Phone(PhoneId);
}
public ViewModel(IBusiness model)
{
Match = new List<Entity>();
Messages = new List<string>();
Filter = 1;
Model = model;
Model.SomethingIsHappening += msg => this.AddMessage(msg);
}
public ViewModel(IBusiness model)
{
Match = new ObservableCollection<Entity>();
Messages = new ObservableCollection<string>();
Filter = 1234;
Model = model;
Model.SomethingIsHappening += msg => this.AddMessage(msg);
}
public override void Load()
{
if (!IsLoaded)
{
var response = this.Client.FindBusinesses(new BusinessQuery(this.Id));
var results = response.Results;
_business = ((results == null || !results.Any()) ? null : results.First());
this.IsLoaded = true;
}
}
public SearchRequestsPage(IBusiness business, Frame frame, Host host, ObservableCollection <Unit> ui_units, ObservableCollection <Order> ui_orders) : base(business, frame)
{
InitializeComponent();
DataContext = this;
Host = host;
UiUnits = ui_units;
UiOrders = ui_orders;
Cities.CheckAll(Business.UnitsOf(Host).Select(unit => unit.City).Distinct());
UnitTypes.CheckAll(Business.UnitsOf(Host).Select(unit => unit.UnitType).Distinct());
Amenities.CheckAll(Business.UnitsOf(Host).Aggregate <Unit, IEnumerable <Amenity> >(new HashSet <Amenity>(), (acc, unit) => acc.Union(unit.Amenities)));
}
public void HandleBusiness(IBusiness business)
{
if (business.Est > DateTime.UtcNow)
{
throw new Exception("can't set established date in the future");
}
Repository.AddBusiness(business);
Logger.Log($"Handled business for {business.Id}");
}
public AddOrderPage(IBusiness business, Frame frame, GuestRequest guest_request, IEnumerable <Unit> units, ObservableCollection <Unit> ui_units, ObservableCollection <Order> ui_orders)
{
InitializeComponent();
DataContext = this;
Business = business;
Frame = frame;
GuestRequest = guest_request;
Units = units;
UiUnits = ui_units;
UiOrders = ui_orders;
}
public ViewUnitPage(IBusiness business, Frame frame, Unit unit, ObservableCollection <Unit> ui_units, ObservableCollection <Order> host_page_ui_orders)
{
InitializeComponent();
Business = business;
Frame = frame;
Unit = unit;
UiOrders = new ObservableCollection <Order>(Business.OrdersOf(unit));
DataContext = this;
UiUnits = ui_units;
HostPageUiOrders = host_page_ui_orders;
}
// Business
public async Task <int> BusinessUpdateAsync(IBusiness business)
{
IDomainEvent <IBusiness> eventRaise;
_dbContext.Entry((Business)business).State = EntityState.Modified;
eventRaise = new BusinessUpdatedEvent(business);
_recordsAffected = await _dbContext.SaveChangesAsync();
business.RaiseDomainEvent(eventRaise);
return(_recordsAffected);
}
public GuestSignInPage(IBusiness business, Session <Guest> guest_session, Frame frame)
{
InitializeComponent();
Business = business;
guest_session.SignInPage = this;
GuestSession = guest_session;
Frame = frame;
EmailValidator = new EmailValidator(email, email_error);
PasswordValidator = new PasswordValidator(password, password_error);
}
static async Task Main(string[] args)
{
Console.WriteLine(">>> Starting >>>>");
var serviceCollection = new ServiceCollection();
var serviceProvider = ConfigureServices(serviceCollection);
IBusiness business = serviceProvider.GetService <IBusiness>();
BusinessQueriesToBeRequestByUI(business);
}
public BusinessDetailsViewModel SetFromBusiness(IBusiness business)
{
Id = business.Id;
Name = business.Name;
Occupation = business.Occupation;
NumberOfEmployees = business.Members.Count.RoundOffMessage();
Description = business.Description;
Headquarters = business.Headquarters;
return(this);
}
public static void Delete <B>(IBusiness <B> business, string id, IReportPayrollView viewReportPayroll) where B : ModelBase
{
if (MessageBox.Show("Are you sure delete payroll?", "Delete", MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.Yes)
{
var payroll = business.Get(id) as ModelBase;
payroll.IsDetele = true;
business.Update((B)payroll);
viewReportPayroll.SearchPayrolls();
}
}
public AdminSignInPage(IBusiness business, Session <Admin> admin_session, Frame frame)
{
InitializeComponent();
Business = business;
admin_session.SignInPage = this;
AdminSession = admin_session;
Frame = frame;
EmailValidator = new EmailValidator(email, email_error);
PasswordValidator = new PasswordValidator(password, password_error);
}
/// <summary>
/// Zmaze vybrane riadky z daneho datagridu
/// </summary>
/// <typeparam name="T">genericky typ Dto</typeparam>
/// <param name="dgv">objekt DataGridView</param>
/// <param name="bo">spravny business objekt na pracu z DB</param>
private void ZmazVybraneZaznamyVDataGride <T>(DataGridView dgv, IBusiness <T> bo)
{
// ak je co mazat
if (((BindingSource)dgv.DataSource).Count != 0)
{
// --------------------------------------------------------------------------------------
// 1. Mazaznie zaznamov v DB
// --------------------------------------------------------------------------------------
// prejdem vsetky riadky a pozriem check box ci je oznaceny ak ano zaznam z DB zmazem
foreach (DataGridViewRow row in dgv.Rows)
{
DataGridViewCheckBoxCell chbCell = (DataGridViewCheckBoxCell)row.Cells[1];
// ak je v danom riadku oznaceny checkbox na mazanie
if (Convert.ToBoolean(chbCell.Value))
{
// ziskam objekt Udalost na ktory je riadok naviazany a vymazem zaznam z databazy
T o = (T)row.DataBoundItem;
// mazem zaznam v DB
bo.VymazZaznamZDB(o);
}
}
// --------------------------------------------------------------------------------------
// 2. Updatujem datagrid a zabezpecim stav scroll baru (aby nevykocil na zaciatok)
// --------------------------------------------------------------------------------------
// ulozim si index riadku ktory je ako prvy viditelny v datagride (maintain state of scrollbar)
int index = dgv.FirstDisplayedScrollingRowIndex;
// refreshnem datagrid
RefreshDataGrid <T>(dgv, bo);
// musim skontrolovat ci este ten index existuje (mohli sme vymazat zaznamy a zaznam ktory bol ako prvy viditelny v scroll bare by uz nemusel byt)
// kontrolujem ci pocet zaznamov >= poctu zaznamov ktore predstavuje index (ci mam dostatocny pocet zaznamov aby som mohol index dat ako prvy v scrollbare)
// pozn. zaznamy v datagride (riadky) su cislovane od 0
if ((((BindingSource)dgv.DataSource).Count - 1) >= index)
{
// ak mam dost zaznamov v datagride
ScrollujDataGridKZaznamu(dgv, index);
}
else if (((BindingSource)dgv.DataSource).Count != 0)
{
// ak nieje 0 zaznamov
// ak nemam dost zaznamov v datagride bude ako prvy v scrollbare, ten kolko mam zaznamov (index posledneho zaznamu)
ScrollujDataGridKZaznamu(dgv, ((BindingSource)dgv.DataSource).Count - 1);
}
}
}
public DecoderService(IBusiness business)
{
try
{
_business = business;
Logger.WriteDebug(MethodBase.GetCurrentMethod(), "Initialize");
}
catch (Exception ex)
{
Logger.WriteError(MethodBase.GetCurrentMethod(), ex);
}
}
public BusinessFacade(IBusiness business, IGroup group, ILocation location, ISpot spot, ISpotUser user,
IEvent @event, IBusinessResponse response, IAtomicBusinessWork atomicBusinessWork, IExceptionLogFacade exceptionLogFacade)
{
_business = business;
_group = group;
_location = location;
_spot = spot;
_user = user;
_event = @event;
_response = response;
_atomicWork = atomicBusinessWork;
_exceptionLogFacade = exceptionLogFacade;
}
static void Main(string[] args)
{
var collection = new ServiceCollection();
collection.AddScoped <IDataAccess, DataAccess>();
collection.AddScoped <IBusiness, BusinessV2>();
var provider = collection.BuildServiceProvider();
IBusiness biz = provider.GetService <IBusiness>();
var uerInterface = new UserInterface(biz);
}
public MainViewModel()
{
try
{
_business = ServiceLocator.Current.GetInstance <IBusiness>();
_mailService = ServiceLocator.Current.GetInstance <IMailService>();
_monitorService = ServiceLocator.Current.GetInstance <IMonitorService>();
_watchdogService = ServiceLocator.Current.GetInstance <IWatchdogService>();
_faxService = ServiceLocator.Current.GetInstance <IFaxService>();
if (_faxService != null)
{
_faxService.EinsatzCreated += (sender, e) => DispatcherHelper.CheckBeginInvokeOnUI(() =>
{
faxService_EinsatzCreated(sender, e);
});
}
_decoderService = ServiceLocator.Current.GetInstance <IDecoderService>();
if (_decoderService != null)
{
_decoderService.StatusChanged += (sender, e) => DispatcherHelper.CheckBeginInvokeOnUI(() =>
{
switch (e.Number)
{
case 1:
DecoderStatus1 = Settings.Default.Decoder1_Mode +
(Settings.Default.Decoder1_Mode == DecoderMode.OFF
? ""
: $"[{e.Status}]");
break;
case 2:
DecoderStatus2 = Settings.Default.Decoder2_Mode +
(Settings.Default.Decoder2_Mode == DecoderMode.OFF
? ""
: $"[{e.Status}]");
break;
}
});
}
#if DEBUG
IsAdminMode = true;
#endif
}
catch (Exception ex)
{
Logger.WriteError(MethodBase.GetCurrentMethod(), ex);
}
}
public PrinterService(IBusiness business, IMapService mapService)
{
try
{
_business = business;
_mapService = mapService;
Logger.WriteDebug(MethodBase.GetCurrentMethod(), "Initialize");
}
catch (Exception ex)
{
Logger.WriteError(MethodBase.GetCurrentMethod(), ex);
}
}
public AlarmVehiclesViewModel(Einsatz _einsatz)
{
try
{
einsatzGuid = _einsatz.Guid;
business = ServiceLocator.Current.GetInstance <IBusiness>();
decoderService = ServiceLocator.Current.GetInstance <IDecoderService>();
if (decoderService != null)
{
decoderService.FmsMessageReceived += (sender, e) => DispatcherHelper.CheckBeginInvokeOnUI(() =>
{
decoderService_MessageFmsReceived(sender, e);
});
}
Vehicles = new ObservableCollection <VehicleViewModel>();
ContextMenuVehicles = new ObservableCollection <Vehicle>(business.GetVehiclesAreEinsatzmittel());
foreach (var _vehicle in _einsatz.Einsatzmittel)
{
//Add vehicle to view
var _alarmVehicle = addVehicle(_vehicle);
if (_alarmVehicle == null)
{
continue;
}
//Transfer Status from main view
var _mainVehicle = ServiceLocator.Current.GetInstance <MainVehiclesViewModel>().Vehicles
.Where(v => v.Vehicle.Id == _alarmVehicle.Vehicle.Id).FirstOrDefault();
if (_mainVehicle != null)
{
_alarmVehicle.ChangeStatus(_mainVehicle.StatusText);
}
//Remove vehicle from ContextMenu if already in alarm list
var _contextMenuVehicle = ContextMenuVehicles.Where(c => c.Id == _vehicle.Id).FirstOrDefault();
if (_contextMenuVehicle != null)
{
ContextMenuVehicles.Remove(_contextMenuVehicle);
}
}
}
catch (Exception ex)
{
Logger.WriteError(MethodBase.GetCurrentMethod(), ex);
}
}
public void Init()
{
//var myConfiguration = new Dictionary<string, string>();
var configuration = new ConfigurationBuilder()
.Build();
var redisConnection = new Microsoft.Extensions.Caching.StackExchangeRedis.RedisCache(new Microsoft.Extensions.Caching.StackExchangeRedis.RedisCacheOptions
{
Configuration = "127.0.0.1:6379",
});
cacheBusiness = new Business(new Provider(redisConnection));
cacheController = new CacheController(configuration, cacheBusiness);
}
public FireboardService(IBusiness business, IDecoderService decoderService, IFaxService faxService)
{
try
{
_business = business;
_decoderService = decoderService;
_faxService = faxService;
Logger.WriteDebug(MethodBase.GetCurrentMethod(), "Initialize");
}
catch (Exception ex)
{
Logger.WriteError(MethodBase.GetCurrentMethod(), ex);
}
}
public MailService(IBusiness business, IAmsService amsService, IFaxService faxService)
{
try
{
_business = business;
_amsService = amsService;
_faxService = faxService;
Logger.WriteDebug(MethodBase.GetCurrentMethod(), "Initialize");
}
catch (Exception ex)
{
Logger.WriteError(MethodBase.GetCurrentMethod(), ex);
}
}
public BusinessController(IBusiness _repository,
ICommon commonRepository,
ISysSetting settingRepository,
IUser userRepository,
INotification notificationService,
IUser_Role userRoleService
)
{
this.repository = _repository;
_commonRepository = commonRepository;
_sysSettingRepository = settingRepository;
_userRepository = userRepository;
_notificationService = notificationService;
_userRoleService = userRoleService;
}
public Form1()
{
InitializeComponent();
container = new UnityContainer();
string path = System.AppDomain.CurrentDomain.SetupInformation.ApplicationBase;
EntlibConfigHelper.LoadUnityConfigFile(container, "", path + "unity.di.config");
EntlibConfigHelper.LoadUnityConfigFile(container, "", path + "unity.aop.config");
b = container.Resolve <IBusiness>();
obj = new BusinessObject()
{
IValue = 12, SValue = "string12"
};
}
/* ********************************************************************************************/
/* ********************************************************************************************/
/* ********************************************************************************************/
/* ****************************************************************************************** */
/* **** Spolocne metody pre DataGridy ******************************************************* */
/* ****************************************************************************************** */
/// <summary>
/// Tato metoda refreshuje dany data grid (dotiahne data nanovo)
/// </summary>
/// <typeparam name="T">genericky typ</typeparam>
/// <param name="dgv">objekt DataGridView</param>
/// <param name="bo">spravny business objekt na pracu z DB</param>
public void RefreshDataGrid <T>(DataGridView dgv, IBusiness <T> bo)
{
// dotiahnem si uzivatelove zaznamy z DB
List <T> dtoList = bo.ZiskajVsetkyZaznamyUzivatela(Username);
// novy binding source
BindingSource bs = new BindingSource();
foreach (T dto in dtoList)
{
bs.Add(dto);
}
// pripojim novy binding source (DataGridView sa sam refreshne)
dgv.DataSource = bs;
}
public static string ChangePassword(string email, string code, string password)
{
try
{
RequestResult oRequestResult = new RequestResult();
using (IBusiness business = ((IBusiness)BusinessFactory.Instance.CreateBusiness(typeof(IBusiness), new object[] { })))
{
oRequestResult.Authentication = (business.changePassword(email, code, password)) ? "Ok" : "Error";
}
return(new JavaScriptSerializer().Serialize(oRequestResult));
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
///
/// </summary>
/// <param name="busKind"></param>
/// <param name="req"></param>
private void DoInit(string busKind, XAIReqBase req)
{
try
{
var builder = new ContainerBuilder();
builder.RegisterType(Type.GetType("XAI.Business.Business" + "BIDU"))
.WithParameter("_Req", req)
.As <IBusiness>();
_Business = builder.Build()
.Resolve <IBusiness>();
}
catch (Exception ex)
{
throw new Exception(ex.InnerException());
}
}
public async Task <ActionResult <dynamic> > PostMasterProduct(MasterProduct masterProduct)
{
IBusiness <MasterProduct> productBusiness = BusinessFactory <MasterProduct> .Create();
bool isInsert = false, isProductNameExisting = false;
isProductNameExisting = await productBusiness.Any(x => (bool)x.Status && x.ProductName.ToLower() == masterProduct.ProductName.ToLower());
if (!isProductNameExisting)
{
isInsert = await productBusiness.Insert(masterProduct);
}
dynamic result = new { isInsert, isProductNameExisting };
return(Ok(result));
}
public async Task <ActionResult <dynamic> > PutTransOrder(long orderId, TransOrder transOrder)
{
if (orderId != transOrder.OrderId)
{
return(BadRequest());
}
IBusiness <TransOrder> orderBusiness = BusinessFactory <TransOrder> .Create();
bool isUpdate = false, isProductUpdate = false;
var orderModel = await orderBusiness.SingleOrDefaultAsync(x => x.OrderId == orderId);
IBusiness <MasterProduct> productBusiness = BusinessFactory <MasterProduct> .Create();
var productModel = await productBusiness.SingleOrDefaultAsync(x => (bool)x.Status && x.ProductId == transOrder.ProductId);
if (orderModel != null && productModel != null && productModel.Availablity && productModel.Quantity >= orderModel.OrderedQuantity)
{
orderModel.OrderedQuantity = transOrder.OrderedQuantity;
orderModel.TotalAmount = transOrder.OrderedQuantity > 0 ? transOrder.OrderedQuantity * productModel.Price : 0;
orderModel.PaymentMode = transOrder.PaymentMode;
orderModel.DeliveryAddress = transOrder.DeliveryAddress;
orderModel.IsCancelled = transOrder.IsCancelled;
orderModel.CancelledDate = DateTime.Now;
orderModel.IsShipped = transOrder.IsShipped;
orderModel.ShippedDate = DateTime.Now;
orderModel.IsDelivered = transOrder.IsDelivered;
orderModel.DeliveredDate = DateTime.Now;
orderModel.IsReturned = transOrder.IsReturned;
orderModel.ReturnedDate = DateTime.Now;
orderModel.OrderedBy = transOrder.OrderedBy;
orderModel.OrderedDate = DateTime.Now;
isUpdate = await orderBusiness.Update(orderModel, orderId);
}
if (orderModel != null && productModel != null && ((orderModel.IsCancelled != null && (bool)orderModel.IsCancelled) ||
(orderModel.IsReturned != null && (bool)orderModel.IsReturned)))
{
productModel.Quantity += orderModel.OrderedQuantity;
productModel.Availablity = productModel.Quantity > 0;
isProductUpdate = await productBusiness.Update(productModel, transOrder.ProductId);
}
dynamic saveResult = new { isUpdate, isProductUpdate };
return(Ok(saveResult));
}
private static void BusinessQueriesToBeRequestByUI(IBusiness business)
{
var getCurrenciesTask = business.GetCurrenciesAsync(new string[] { Currencies.USD, Currencies.EUR });
getCurrenciesTask.Wait();
var currencies = getCurrenciesTask.Result;
Console.WriteLine(currencies.FirstOrDefault());
var getCurrencyExchangeTask = business.GetExchangeRatesAsync(Currencies.EUR);
var exchangeRateData = getCurrencyExchangeTask.Result;
Console.WriteLine($"1 {Currencies.EUR} = {exchangeRateData.Rates[Currencies.USD]} {Currencies.USD}");
BuyPrice btcUsdBuyPrice = business.GetBuyPriceAsync(CryptoFiatPairs.BTCUSD).Result;
Console.WriteLine($"1 {btcUsdBuyPrice.Base} = { btcUsdBuyPrice.Amount} {btcUsdBuyPrice.Currency}");
}
public AlarmViewModel(Einsatz einsatz)
{
try
{
_einsatzGuid = einsatz.Guid;
_business = ServiceLocator.Current.GetInstance <IBusiness>();
AlarmappVM = new AlarmAlarmappViewModel(einsatz);
DataVM = new AlarmDataViewModel(einsatz);
RouteVM = new AlarmRouteViewModel(einsatz);
TimerVM = new AlarmTimerViewModel(einsatz);
VehiclesVM = new AlarmVehiclesViewModel(einsatz);
}
catch (Exception ex)
{
Logger.WriteError(MethodBase.GetCurrentMethod(), ex);
}
}
private void RemoveUpdate(IBusiness removeItem)
{
if (removeItem is IUpdate)
{
IUpdate iupdate = removeItem as IUpdate;
if (lisUpdate.Contains(iupdate))
{
lisUpdate.Remove(iupdate);
}
}
if (removeItem is ILateUpdate)
{
ILateUpdate ilateUpdate = removeItem as ILateUpdate;
if (lisLateUpdate.Contains(ilateUpdate))
{
lisLateUpdate.Remove(ilateUpdate);
}
}
}
/// <summary>
/// Converto i nomi di proprietà in nomi di campo ADO.NET
/// </summary>
/// <param name="nameField">Array di stringhe contenente i nomi dei campi</param>
public static string ConvertNameField(string sortString, IBusiness business)
{
if(business.FieldNameAlias == null)
return sortString;
string[] nameField = sortString.Split(',');
StringBuilder risultato=new StringBuilder();
for(int i=0; i<nameField.Length; i++)
{
string[] sortArray = nameField[i].Split(' ');
object valore = business.FieldNameAlias[sortArray[0]];
if(valore != null)
{
sortArray[0] = valore.ToString();
nameField[i] = sortArray[0] + " " + sortArray[1];
}
else
{
if(!business.OrigineDati.Tables[business.TableName].Columns.Contains(sortArray[0]) && business.OrigineDati.Tables[business.TableName].Columns.Contains(sortArray[0] + business.TableName))
{
nameField[i] = sortArray[0] + business.TableName + " " + sortArray[1];
}
}
if(risultato.ToString() != string.Empty) risultato.Append(", ");
risultato.Append(nameField[i]);
}
return risultato.ToString();
}
public void Add(IBusiness business)
{
_businessDictionary.Add(business.Id, business);
}
public static void SetUp(TestContext context)
{
_response = (new ResponseDecoderHelper()).BusinessResponse;
_business = _response.Results.First();
}
public Presenter(IBusiness model)
{
Model = model;
Model.SomethingIsHappening += msg => this.View.NotifyUser(String.Format("[{0:hh:mm:ss}] {1}", DateTime.Now, msg));
}
public SearchController(IBusiness business, PageConfig pageConfig)
{
_business = business;
_pageConfig = pageConfig;
}
public HomeController(IParser parser, IBusiness business, PageConfig pageConfig)
{
_business = business;
_parser = parser;
_pageConfig = pageConfig;
}
public HomeController(IBusiness businessObj)
{
_businessObj = businessObj;
}
public static void DumpBusiness(IBusiness business, int depth, int indent = 0)
{
PrintName(business, indent);
DumpBaseEntity(business, depth, indent);
}
/// <summary>
/// Converto i nomi di proprietà in nomi di campo ADO.NET
/// </summary>
/// <param name="business">Oggetto business contenente i nomi ADO.NET</param>
public void ConvertNameField(IBusiness business)
{
foreach(SQuery squery in this)
{
if(business.FieldNameAlias != null)
{
object valore = business.FieldNameAlias[squery.NomeCampo];
if(valore != null)
squery.NomeCampo = valore.ToString();
}
}
}
public BackendService(IBusiness domainObject)
{
_domainObject = domainObject;
}
public BusinessArgs(IBusiness business)
{
}
