public FrmSoporteAdmedia()
{
InitializeComponent();
String ApiResourcePath = "http://localhost:51249/api/SoporteAdmedia";
_RESTSoporteAdmediaService = new RESTService <SoporteAdmedia>(ApiResourcePath, Statics.Token);
}
public MainViewModel(Store <ApplicationState> store, IRESTService restService)
{
this.store = store;
this.restService = restService;
//create new Order
store.Dispatch(new CreateOrderAction());
//bindable properties
CanOrder = store.Grab(state => !state.CurrentOrder.OrderDetails.IsEmpty);
IsBusy = store.Grab(state => state.UI.ShowSpinner);
var orderDetails = store.Grab(state => state.CurrentOrder.OrderDetails);
var pizzas = store.Grab(state => state.Data.Pizzas);
var sizes = store.Grab(state => state.Data.Sizes);
var toppings = store.Grab(state => state.Data.Toppings);
OrderDetailsStream = Observable.CombineLatest(orderDetails, pizzas, sizes, toppings, MapToOrderDetailViewModels);
TotalPriceStream = OrderDetailsStream.Select(vms =>
{
var total = vms.Sum(vm => vm.Price);
return(string.Format("Total: {0:C}", total));
});
//Commands
NewOrderDetailCommand = new Command(GoToPizzaSelection);
DeleteOrderDetailCommand = new Command <OrderDetailViewModel>(OnDeleteOrderDetail);
//OrderCommand = new Command(MakeOrder);
OrderCommand = new SubjectCommand();
var currentOrder = store.Grab(state => state.CurrentOrder);
OrderCommand.Subject.WithLatestFrom(currentOrder, async(_, orderstate) => await MakeOrder(orderstate)).Subscribe();
}
public MainWindow()
{
InitializeComponent();
_apiService = new RESTService("http://localhost:60879/api");
InitializeTimeTable();
}
public MainForm()
{
InitializeComponent();
String ApiResourcePath = "http://localhost:51249/api/Product";
_RESTProductService = new RESTService <Product>(ApiResourcePath, Statics.Token);
}
//the main Application and its functionalities
public App()
{
AuthenticationService = DependencyService.Get <IRESTService>();
var rest = new ManagerRESTService(new RESTService());
// MainPage = new NavigationPage(new LoginPage());
// NavigateAsync(FirstPage.Login);
Debug.WriteLine("App testing userloggedIn");
try
{
if (rest.IsAutheticated())
{
Debug.WriteLine("userloggedIn is true");
MainPage = new NavigationPage(new AccountsPage());
}
else
{
Debug.WriteLine("userloggedIn is false");
MainPage = new NavigationPage(new LoginPage());
}
}
catch (Exception err)
{
Debug.WriteLine("Caught error: {0}.", err);
}
}
public AddAppointmentWindow(IRESTService apiService)
{
InitializeComponent();
_apiService = apiService;
DataContext = this;
IsDateSelected = false;
AppointmentsForDateItemsControl.ItemsSource = appointmentTimes;
}
public CheckInViewer(IRESTService apiService, CheckIn checkIn, bool canFinish = false)
{
DataContext = this;
CanFinish = canFinish;
CheckIn = checkIn;
_apiService = apiService;
InitializeComponent();
}
private async Task <List <T> > ItemsAlteredFetchFunc(IRESTService apiService, string resourceUri, DateTime syncByDate)
{
//Console.WriteLine("Syncing by date: {0}", syncByDate);
DateTime today = DateTime.Now.Subtract(DateTime.Now.TimeOfDay);
DateTime tomorrow = today.AddDays(1);
return(await apiService.GetAllBetweenDatesAsync <T>(resourceUri, syncByDate, tomorrow, null, true));
//return await _apiService.GetAllAfterDateAsync<T>(resourceUri, new DateTime(), syncBy);
}
/// <summary>
/// The default function for API calls if no delegate is passed in the constructor.
/// </summary>
/// <param name="apiService">The IRESTService instance to be used to make the API call.</param>
/// <param name="resourceUri">The URL path beyond the base URL.</param>
/// <param name="syncBy">The value to sync by, elements with greater Id will be returned.</param>
/// <returns>List of new T elements, may be empty.</returns>
private async Task <List <T> > DefaultDatabaseFetchFunc(IRESTService apiService, string resourceUri, int syncBy)
{
//Console.WriteLine("Sync by id: {0}", syncBy);
DateTime today = DateTime.Now.Subtract(DateTime.Now.TimeOfDay);
DateTime tomorrow = today.AddDays(1);
return(await apiService.GetAllBetweenDatesAsync <T>(resourceUri, today, tomorrow, syncBy > -1?syncBy : (int?)null));
//return await _apiService.GetAllAfterDateAsync<T>(resourceUri, new DateTime(), syncBy);
}
public CrlFundListVm(IRESTService rESTService) : base()
{
this._RESTService = rESTService;
LineVm = new FdLineVm("X_Date_Value", "Y_String_Value", "TITLE", "日期", "净值涨幅");
//LineVm.LineColor = "lightblue";
GridVm = new GridVm(this);
ToolBar = new ToolBarTrayVm(this);
UnitLineVm = new FdLineVm("X_Date_Value", "Y_String_Value", "TITLE", "日期", "单位净值");
//UnitLineVm.LineColor = "lightblue";
}
public void Load(SerializationReader reader, Fallen8 fallen8)
{
_uriPattern = reader.ReadString();
_address = IPAddress.Parse(reader.ReadString());
_port = reader.ReadUInt16();
_service = LoadServiceFromSerialization(reader, fallen8);
_service.Load(reader, fallen8);
StartService();
}
public CheckInTimeTableService(IRESTService apiService)
{
_isFirstSync = true;
CheckIns = new List <CheckIn>();
_apiService = apiService;
_dataSyncService = new PollingDataSyncService <CheckIn>(5000, _apiService);
_dataSyncService.NewData += OnNewElementsFound;
_dataSyncService.AlteredData += OnAlteredElementsFound;
_timer = new Timer(5000);
_timer.Elapsed += OnAppointmentSortRequest;
}
/// <summary>
/// Initializes a new PollingDataSyncService<T> instance
/// </summary>
/// <param name="interval">Polling rate in milliseconds.</param>
/// <param name="apiService">The IRESTService instance to be used to make API calls.</param>
/// <param name="dataSyncDelegate">Will be invoked as the synchronization method.</param>
public PollingDataSyncService(int interval, IRESTService apiService, DataSyncDelegate <T> dataSyncDelegate = null)
{
_timer = new Timer(interval);
_timer.Elapsed += SyncWithDatabase;
_repository = new List <T>();
_apiService = apiService;
if (dataSyncDelegate != null)
{
_dataSyncDelegate = dataSyncDelegate;
}
else
{
_dataSyncDelegate = new DataSyncDelegate <T>(DefaultDatabaseFetchFunc);
}
_apiResourceUri = new StringBuilder(typeof(T).Name.ToLower()).Append("s").ToString();
}
public void SetUp()
{
var mock = new Mock <IAppDbContext>();
mock.Setup(x => x.Users)
.Returns(new FakeDbSet <UserModel>
{
new UserModel {
NickName = "nickName1", FullName = "fullName1"
},
new UserModel {
NickName = "nickName2", FullName = "fullName2"
},
});
_dbMock = mock.Object;
_RESTService = new RESTService(_dbMock);
}
public static FunDetail GetFunDetail(IRESTService rESTService, string code)
{
Dictionary <string, string> dic = new Dictionary <string, string>
{
{ "code", code }
};
var res = rESTService.Get(FDConst.FundDetailUrl, dic);
FunDetail fundInfo = JsonConvert.DeserializeObject <FunDetail>(res);
if (fundInfo.code.Equals(200))
{
return(fundInfo);
}
else
{
throw new Exception(string.Format(@"Get Failed!\nurl{0}", FDConst.FundDetailUrl));
}
}
/// <summary>
/// funding list
/// </summary>
/// <returns></returns>
public static FundInfo GetFundingList(IRESTService rESTService)
{
Dictionary <string, string> dic = new Dictionary <string, string>
{
{ "code", "007301,202015,007339" }
};
var res = rESTService.Get(FDConst.FundBaseUrl, dic);
FundInfo fundInfo = JsonConvert.DeserializeObject <FundInfo>(res);
if (fundInfo.code.Equals(200))
{
return(fundInfo);
}
else
{
throw new Exception("Get Failed!");
}
}
//! END section: Globals
//! Section: Methods
/// <summary>
/// Constructor of the service that handles dependency injection of required services
/// </summary>
/// <param name="config">GitHub API configuration</param>
/// <param name="restService">Service to perform basic REST request</param>
/// <param name="graphQLService">Service to perform GraphQL requests</param>
public GitHubService(IOptions <API_Config> config, IRESTService restService, IGraphQLService graphQLService)
{
_config = config.Value;
_restService = restService;
_graphQLService = graphQLService;
}
public HostingRESTService(IRESTService service, params Uri[] baseAdresses)
{
_service = service;
_host = new WebServiceHost(service, baseAdresses);
}
public AddPatientWindow(IRESTService apiService)
{
InitializeComponent();
_apiService = apiService;
DataContext = this;
}
public ManagerRESTService(IRESTService service)
{
restService = service;
}
public void Load(SerializationReader reader, Fallen8 fallen8)
{
_uriPattern = reader.ReadString ();
_address = IPAddress.Parse (reader.ReadString ());
_port = reader.ReadUInt16 ();
_service = LoadServiceFromSerialization (reader, fallen8);
_service.Load (reader, fallen8);
StartService ();
}
public void Initialize(Fallen8 fallen8, IDictionary <string, object> parameter)
{
InitializeParams(fallen8, parameter);
_service = CreateService(fallen8, parameter);
StartService();
}
public ProductManager(IRESTService service)
{
this.restService = service;
}
public void Initialize(Fallen8 fallen8, IDictionary<string, object> parameter)
{
InitializeParams (fallen8, parameter);
_service = CreateService (fallen8, parameter);
StartService ();
}
public void TearDown()
{
_RESTService = null;
}
