public SmsViewModel(IPhoneService phone, IUserDialogService dialogs)
{
this.Send = new Command(() => {
phone.Sms(this.PhoneNumber, this.Message);
dialogs.Alert("Message sent");
});
}
public RentModelMVC(string category, IPhoneService phone)
{
this.service = new CategoryService();
this.phone = phone;
Init(service.Get(category));
}
public ServicesHistoryPageViewModel(IApiService apiService, IDialogService dialogService, ILoginViewModel loginViewModel, INavigationService navigationService, IPhoneService phoneService, IValidatorService validatorService, IPermissionService permissionService)
{
EndDate = DateTime.Now;
InitDate = EndDate.AddYears(-1);
MaximumDate = DateTime.Now;
IsCO = AppConfigurations.Brand == "emi";
IsUY = AppConfigurations.Brand == "ucm";
Cities = new ObservableCollection <City>();
Doctors = new ObservableCollection <Doctor>();
Services = new ObservableCollection <ServicesType>();
ServicesHistory = new ObservableCollection <ServiceHistoryViewModel>();
Specialities = new ObservableCollection <Speciality>();
Minors = new ObservableCollection <Minor>();
IsVisiblePatient = false;
this.apiService = apiService;
this.dialogService = dialogService;
this.loginViewModel = loginViewModel;
this.navigationService = navigationService;
this.phoneService = phoneService;
this.validatorService = validatorService;
this.permissionService = permissionService;
}
public InvoiceViewModel()
{
apiService = ServiceLocator.Current.GetInstance <IApiService>();
dialogService = ServiceLocator.Current.GetInstance <IDialogService>();
loginViewModel = ServiceLocator.Current.GetInstance <ILoginViewModel>();
phoneService = ServiceLocator.Current.GetInstance <IPhoneService>();
}
protected override void InitFromBundle(IMvxBundle parameters)
{
base.InitFromBundle(parameters);
phoneService = Mvx.Resolve <IPhoneService>();
this.NewUser = getNewUser();
PasswordResets = new PasswordReset();
}
public Connection(INavigationService navService, SettingsModel setModel, UDCListModel udc, IPhoneService phoneService)
{
phoneService.Deactivated += new EventHandler<Microsoft.Phone.Shell.DeactivatedEventArgs>(phoneService_Deactivated);
phoneService.Activated += new EventHandler<Microsoft.Phone.Shell.ActivatedEventArgs>(phoneService_Activated);
Crypt.init();
this.LastSendOperation = -1;
this.LastReceiveOperation = -1;
this.navService = navService;
this.setModel = setModel;
this.udc = udc;
this.VoicePort = null;
this.keepaliveWorker = new DispatcherTimer();
keepaliveWorker.Interval = TimeSpan.FromSeconds(20);
keepaliveWorker.Tick += new EventHandler(keepaliveWorker_Tick);
Analyzing = false;
this.socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
//this.sendArgs = new SocketAsyncEventArgs();
//this.receiveArgs = new SocketAsyncEventArgs();
//sendArgs.UserToken = true; // UserToken zeigt an, ob das Objekt gerade verfügbar ist.
//receiveArgs.UserToken = true;
//sendArgs.Completed += new EventHandler<SocketAsyncEventArgs>(Send_Completed);
//receiveArgs.Completed += new EventHandler<SocketAsyncEventArgs>(Receive_Completed);
Connect();
}
/// <summary>
/// Tombstones the class/property.
/// </summary>
/// <param name="phoneService">An instance of the phone service.</param>
/// <param name="owner">The owner of the property or null if it is the root.</param>
/// <param name="property">The property to persist or null if the value is the root.</param>
/// <param name="value">The value to persist.</param>
/// <param name="rootKey">The key to use for persistance.</param>
public virtual void Tombstone(IPhoneService phoneService, object owner, PropertyInfo property, object value, string rootKey)
{
if(value == null)
return;
var type = value.GetType();
if((type.IsClass || type.IsInterface) && !typeof(string).IsAssignableFrom(type))
{
var key = GetStateKey(value, rootKey);
var conductor = value as IConductor;
if(conductor != null)
{
var items = conductor.GetConductedItems().OfType<object>().ToList();
phoneService.State[key + "|ActiveItemIndex"] = items.IndexOf(conductor.ActiveItem);
GetPersistableItems(items, key)
.Apply(x => x.Item2.Tombstone(phoneService, value, null, x.Item1, x.Item3));
}
GetPersistableProperties(value, key)
.Apply(x => x.Item2.Tombstone(phoneService, value, x.Item1, x.Item1.GetValue(value, null), x.Item3));
}
else phoneService.State[rootKey] = value;
}
public CallViewModel(INavigationService navigationService, IDialogService dialogService, IPhoneService phoneService, IApiService apiService)
{
this.apiService = apiService;
this.navigationService = navigationService;
this.dialogService = dialogService;
this.phoneService = phoneService;
}
public ChangePasswordPageViewModel(IApiService apiService, IDialogService dialogService, INavigationService navigationService, IPhoneService phoneService)
{
this.apiService = apiService;
this.dialogService = dialogService;
this.navigationService = navigationService;
this.phoneService = phoneService;
}
public RabbitMiddleware(IMiddlewareContext context, ILogger logger, IApplicationService application, IEmailService email, IPhoneService phone)
: base(context, logger)
{
Application = application ?? throw new ArgumentNullException(nameof(application));
Email = email ?? throw new ArgumentNullException(nameof(email));
Phone = phone ?? throw new ArgumentNullException(nameof(phone));
}
public static string[] IsValid(this User user, IPhoneService phone)
{
/*It should be better that that..*/
if (string.IsNullOrEmpty(user.Password))
{
return new[] { "missing password" }
}
;
//if (string.IsNullOrEmpty(user.Email))
// return false;
if (string.IsNullOrEmpty(user.Name))
{
return new[] { "missing full name" }
}
;
if (string.IsNullOrEmpty(user.UserName))
{
return new[] { "missing username" }
}
;
if (null == user.DOB)
{
return new[] { "missing day of birth" }
}
;
if (!phone.IsGlobalPhoneNumber(user.Phone))
{
return new[] { "invalid phone number.\r\nPlease provide in international format (e.g: +1889123456)" }
}
;
return(new string[] { });
}
public EmployeeController(IEmployeeService employeeService,
IPersonService personService,
IBusinessEntityAddressService businessEntityAddressService,
IBusinessEntityContactService businessEntityContactService,
IPhoneService phoneService,
IAddressService addressService,
IAddressTypeService addressTypeService,
IPhoneTypeService phoneTypeService,
IContactTypeService contactTypeService,
IBusinessEntityService businessEntityService,
IUnitOfWorkAsync unitOfWork)
{
this.businessEntityService = businessEntityService;
this.employeeService = employeeService;
this.unitOfWork = unitOfWork;
this.addressService = addressService;
this.personService = personService;
this.businessEntityContactService = businessEntityContactService;
this.businessEntityAddressService = businessEntityAddressService;
this.personService = personService;
this.phoneService = phoneService;
this.addressTypeService = addressTypeService;
this.phoneTypeService = phoneTypeService;
this.contactTypeService = contactTypeService;
}
public BuyModelMVC(string car, IPhoneService phone)
{
this.service = new CarSearchService();
this.phone = phone;
Init(service.GetCar(car));
}
public SetUserPhoneCommandHandler(
IPhoneService userService,
IIdentityService identityService)
{
_userService = userService;
_identityService = identityService;
}
public AttendingUserDetailsViewModel(ICTimeService cTimeService, IApplicationStateService applicationStateService, IContactsService contactsService, IDialogService dialogService, IPhoneService phoneService, IEmailService emailService)
{
Guard.NotNull(cTimeService, nameof(cTimeService));
Guard.NotNull(applicationStateService, nameof(applicationStateService));
Guard.NotNull(contactsService, nameof(contactsService));
Guard.NotNull(dialogService, nameof(dialogService));
Guard.NotNull(phoneService, nameof(phoneService));
Guard.NotNull(emailService, nameof(emailService));
this._cTimeService = cTimeService;
this._applicationStateService = applicationStateService;
this._contactsService = contactsService;
this._dialogService = dialogService;
this._phoneService = phoneService;
this._emailService = emailService;
this.LoadAttendingUser = UwCoreCommand.Create(this.LoadAttendingUserImpl)
.HandleExceptions()
.ShowLoadingOverlay(CTime2Resources.Get("Loading.Employee"));
this.LoadAttendingUser.ToProperty(this, f => f.AttendingUser, out this._attendingUserHelper);
var canCall = Observable
.Return(this._phoneService.CanCall)
.CombineLatest(this.WhenAnyValue(f => f.AttendingUser), (serviceCanCall, user) =>
serviceCanCall && string.IsNullOrWhiteSpace(user?.PhoneNumber) == false);
this.Call = UwCoreCommand.Create(canCall, this.CallImpl)
.HandleExceptions();
var canSendMail = this.WhenAnyValue(f => f.AttendingUser, selector: user => string.IsNullOrWhiteSpace(user?.EmailAddress) == false);
this.SendMail = UwCoreCommand.Create(canSendMail, this.SendMailImpl)
.HandleExceptions();
this.AddAsContact = UwCoreCommand.Create(this.AddAsContactImpl)
.HandleExceptions();
}
/// <summary>
/// Tombstones the class/property.
/// </summary>
/// <param name="phoneService">An instance of the phone service.</param>
/// <param name="owner">The owner of the property or null if it is the root.</param>
/// <param name="property">The property to persist or null if the value is the root.</param>
/// <param name="value">The value to persist.</param>
/// <param name="rootKey">The key to use for persistance.</param>
public virtual void Tombstone(IPhoneService phoneService, object owner, PropertyInfo property, object value, string rootKey)
{
if (value == null)
{
return;
}
var type = value.GetType();
if (IsComplexType(type))
{
var key = GetStateKey(value, rootKey);
var conductor = value as IConductor;
if (conductor != null)
{
var items = conductor.GetConductedItems().OfType <object>().ToList();
phoneService.State[key + "|ActiveItemIndex"] = items.IndexOf(conductor.ActiveItem);
GetPersistableItems(items, key)
.Apply(x => x.Item2.Tombstone(phoneService, value, null, x.Item1, x.Item3));
}
GetPersistableProperties(value, key)
.Apply(x => x.Item2.Tombstone(phoneService, value, x.Item1, x.Item1.GetValue(value, null), x.Item3));
}
else
{
phoneService.State[rootKey] = value;
}
}
public PhonesController(IPhoneService phoneService,
ICombiningUserOfferService combiningUserOfferService,
IPhoneDataCapture phoneDataCapture)
{
_phoneService = phoneService;
_combiningUserOfferService = combiningUserOfferService;
_phoneDataCapture = phoneDataCapture;
}
private ContactExtensions()
{
#if !PORTABLE
this.SmsService = new SmsService();
this.EmailService = new EmailService();
this.PhoneService = new PhoneService();
#endif
}
public ContactViewModel(IConnectionService connectionService,
INavigationService navigationService, IDialogService dialogService,
IContactDataService contactDataService, IPhoneService phoneService)
: base(connectionService, navigationService, dialogService)
{
_contactDataService = contactDataService;
_phoneService = phoneService;
}
public PhoneController(
IPhoneService phoneService,
IMapper mapper,
NotificationHandler notifications) : base(notifications)
{
_phoneService = phoneService;
_mapper = mapper;
}
public PhoneController(IPhoneService phoneService)
{
if (phoneService == null)
{
throw new NullReferenceException("phoneService");
}
_phoneService = phoneService;
}
public RequestSoftwareVersion()
{
IPhoneService phoneService = ServiceLocator.Current.GetInstance <IPhoneService>();
Action = "GetSoftwareVersion";
Code = phoneService.IsiOS ? "Version App IOs" : "Version App Android";
Controller = "Contents";
}
public ProductController(IPhoneService phoneService, ISmartWatchService smartWatchService,
IElectronicBookService electronicBookService, IDataRepository dataRepository)
{
_dataRepository = dataRepository;
_phoneService = new Lazy <IPhoneService>(() => phoneService);
_smartWatchService = new Lazy <ISmartWatchService>(() => smartWatchService);
_electronicBookService = new Lazy <IElectronicBookService>(() => electronicBookService);
}
public BookingStatusBottomBarViewModel(IPhoneService phoneService, IBookingService bookingService, IPaymentService paymentService, IAccountService accountService)
{
_phoneService = phoneService;
_bookingService = bookingService;
_paymentService = paymentService;
_accountService = accountService;
GetIsCmtRideLinq();
}
public CrowdApiController(ICrowdService crowdService, IPartImageService partImageService, IDiscountService discountService, IFollowerService followerService, IPhoneService phoneService, IParticipationService participationService)
{
_discountService = discountService;
_crowdService = crowdService;
_partImageService = partImageService;
_followerService = followerService;
_phoneService = phoneService;
_participationService = participationService;
}
public CrowdApiController(ICrowdService crowdService, IPartImageService partImageService, IDiscountService discountService, IFollowerService followerService, IPhoneService phoneService, IParticipationService participationService)
{
_discountService = discountService;
_crowdService = crowdService;
_partImageService = partImageService;
_followerService = followerService;
_phoneService = phoneService;
_participationService = participationService;
}
public FamilyPageViewModel(IApiService apiService, IDialogService dialogService, INavigationService navigationService, IPhoneService phoneService)
{
this.apiService = apiService;
this.dialogService = dialogService;
this.navigationService = navigationService;
this.phoneService = phoneService;
Members = new ObservableCollection <PersonViewModel>();
}
public ServicesEnabledViewModel()
{
Message = new Message();
apiService = ServiceLocator.Current.GetInstance <IApiService>();
dialogService = ServiceLocator.Current.GetInstance <IDialogService>();
navigationService = ServiceLocator.Current.GetInstance <INavigationService>();
phoneService = ServiceLocator.Current.GetInstance <IPhoneService>();
servicesPageViewModel = ServiceLocator.Current.GetInstance <IServicesPageViewModel>();
}
/// <summary>
/// Resurrects the class/property.
/// </summary>
/// <param name="phoneService">An instance of the phone service.</param>
/// <param name="owner">The owner of the property or null if it is the root.</param>
/// <param name="property">The property to resurrect or null if the value is the root.</param>
/// <param name="value">The value to resurrect.</param>
/// <param name="rootKey">The key to use for resurrection.</param>
public virtual void Resurrect(IPhoneService phoneService, object owner, PropertyInfo property, object value, string rootKey)
{
var type = property == null?value.GetType() : property.PropertyType;
if (IsComplexType(type))
{
if (value == null)
{
return;
}
var key = GetStateKey(value, rootKey);
var conductor = value as IConductor;
if (conductor != null)
{
var items = conductor.GetConductedItems().OfType <object>().ToList();
var conductorId = key + "|ActiveItemIndex";
if (phoneService.State.ContainsKey(conductorId))
{
var index = Convert.ToInt32(phoneService.State[conductorId]);
if (index < items.Count)
{
conductor.ActivateItem(items[index]);
}
}
else
{
conductor.ActivateItem(items.FirstOrDefault());
}
GetPersistableItems(items, key)
.Apply(x => x.Item2.Resurrect(phoneService, value, null, x.Item1, x.Item3));
}
GetPersistableProperties(value, key)
.Apply(x => x.Item2.Resurrect(
phoneService,
value,
x.Item1,
IsComplexType(x.Item1.PropertyType) ? x.Item1.GetValue(value, null) : null,
x.Item3
)
);
}
else
{
object persisted;
if (phoneService.State.TryGetValue(rootKey, out persisted))
{
property.SetValue(owner, persisted, null);
}
}
}
public SMSMessageSender()
{
var builder = new ContainerBuilder();
builder.RegisterModule(new PhoneServiceModule());
var container = builder.Build();
_phService = container.Resolve <IPhoneService>();
_isException = new Random().Next(1, 101) > 66;
}
/// <summary>
/// Initializes a new instance of the <see cref="StorageCoordinator"/> class.
/// </summary>
/// <param name="container">The container.</param>
/// <param name="phoneService">The phone service.</param>
/// <param name="storageMechanisms">The storage mechanisms.</param>
/// <param name="handlers">The handlers.</param>
public StorageCoordinator(IPhoneContainer container, IPhoneService phoneService, IEnumerable<IStorageMechanism> storageMechanisms, IEnumerable<IStorageHandler> handlers) {
this.container = container;
this.phoneService = phoneService;
this.storageMechanisms = storageMechanisms.ToList();
handlers.Apply(x => AddStorageHandler(x));
phoneService.Resurrecting += () => currentRestoreMode = StorageMode.Any;
phoneService.Continuing += () => storageMechanisms.Apply(x => x.ClearLastSession());
}
public PhonesController(IPhoneRepository phoneRepository,
IPhoneService phoneService,
IMapper mapper,
INotifier notifier)
: base(notifier)
{
_phoneRepository = phoneRepository;
_phoneService = phoneService;
_mapper = mapper;
}
public LoaderPageViewModel(IApiService apiService, IDialogService dialogService, IExceptionService exceptionService, IFileService fileService, INavigationService navigationService, ILoginViewModel loginViewModel, IPhoneService phoneService)
{
this.apiService = apiService;
this.dialogService = dialogService;
this.exceptionService = exceptionService;
this.fileService = fileService;
this.navigationService = navigationService;
this.loginViewModel = loginViewModel;
this.phoneService = phoneService;
}
public BeneficiariesPageViewModel(IApiService apiService, IDialogService dialogService, INavigationService navigationService, IPhoneService phoneService)
{
this.apiService = apiService;
this.dialogService = dialogService;
this.navigationService = navigationService;
this.phoneService = phoneService;
Beneficiaries = new ObservableCollection <Person>();
LoadBeneficiaries();
}
public SmsViewModel(IPhoneService phone, IUserDialogService dialogs)
{
this.Send = new Command(() => {
if (this.Count > 140)
dialogs.Alert("Text message is too big");
else {
phone.Sms(this.PhoneNumber, this.Message);
dialogs.Alert("Message sent");
}
});
}
public LoginViewModel(IStorageService storageService, IUserService userService, IPhoneService phoneService,
IMessageService messageService, IEncryptionService encryptionService, IMvxMessenger messenger, IPopupHelper helper) : base(messenger, helper)
{
_storageService = storageService;
_userService = userService;
_phoneService = phoneService;
_messageService = messageService;
_encryptionService = encryptionService;
ProceedCommand = new MvxCommand(ProceedCommandAction, ValidatePassword);
}
public void setupData()
{
//add and test phonecodes
phoneService = new PhoneService();
applicantService = new ApplicantService();
ApplicantModel applicant = new ApplicantModel { applicantId = 1, firstName = "Wes", lastName = "Reisz", lastUpdated = DateTime.Now, middleInitial = "T", ssn = "123456789", suffix = "JR" };
applicantService.addOrUpdateApplicant(applicant);
PhoneCodeModel hm = new PhoneCodeModel { phoneCodeDescription = "Home Phone", phoneCode = "AA", lastModifiedDate = DateTime.Now };
phoneService.addPhoneCd(hm);
phoneService.addOrUpdatePhone(new PhoneModel {applicantId=applicant.applicantId,createDate=DateTime.Now, lastModifiedDate=DateTime.Now, phoneCd=hm.phoneCode,phoneNumber=1231231233});
}
/// <summary>
/// Resurrects the class/property.
/// </summary>
/// <param name="phoneService">An instance of the phone service.</param>
/// <param name="owner">The owner of the property or null if it is the root.</param>
/// <param name="property">The property to resurrect or null if the value is the root.</param>
/// <param name="value">The value to resurrect.</param>
/// <param name="rootKey">The key to use for resurrection.</param>
public virtual void Resurrect(IPhoneService phoneService, object owner, PropertyInfo property, object value, string rootKey)
{
var type = property == null ? value.GetType() : property.PropertyType;
if(IsComplexType(type))
{
if(value == null)
return;
var key = GetStateKey(value, rootKey);
var conductor = value as IConductor;
if(conductor != null)
{
var items = conductor.GetConductedItems().OfType<object>().ToList();
var conductorId = key + "|ActiveItemIndex";
if(phoneService.State.ContainsKey(conductorId))
{
var index = Convert.ToInt32(phoneService.State[conductorId]);
if(index < items.Count)
conductor.ActivateItem(items[index]);
}
else
conductor.ActivateItem(items.FirstOrDefault());
GetPersistableItems(items, key)
.Apply(x => x.Item2.Resurrect(phoneService, value, null, x.Item1, x.Item3));
}
GetPersistableProperties(value, key)
.Apply(x => x.Item2.Resurrect(
phoneService,
value,
x.Item1,
IsComplexType(x.Item1.PropertyType) ? x.Item1.GetValue(value, null) : null,
x.Item3
)
);
}
else
{
object persisted;
if(phoneService.State.TryGetValue(rootKey, out persisted))
property.SetValue(owner, persisted, null);
}
}
public ViewModelLocator()
{
navigationService = new NavigationService();
phoneService = new PhoneService();
}
public SmsViewModel(IPhoneService phone, IUserDialogService dialogs) {
this.Send = new Command(() => {
phone.Sms(this.PhoneNumber, this.Message);
dialogs.Alert("Message sent");
});
}
public FileSystemCache(IPhoneService phoneService)
{
phoneService.Deactivated += (sender, args) => SaveToDisk();
phoneService.Closing += (sender, args) => SaveToDisk();
}
public PhoneViewModel(IPhoneService phone)
{
this.Call = new Command(() => phone.Call(String.Empty, this.PhoneNumber));
}
/// <summary>
/// Initializes a new instance of the <see cref="PhoneStateStorageMechanism"/> class.
/// </summary>
/// <param name="container">The container.</param>
/// <param name="phoneService">The phone service.</param>
public PhoneStateStorageMechanism(IPhoneContainer container, IPhoneService phoneService) {
this.container = container;
this.phoneService = phoneService;
}
public TombstoneSurvivalStateStorage(IPhoneService phone)
{
_phone = phone;
}
public void RememberActivePanorama(IPhoneService phone)
{
TombstoneSurvivalEngine.SetupFor<ColdPanorama>(this, phone);
}
public JsonService(IPhoneService phoneService)
{
this.phoneService = phoneService;
}
public PhonesController(IPhoneService phoneService)
{
this.phones = phoneService;
}
public PhoneViewModel(IPhoneService phone) {
this.Call = new Command(() => phone.Call(this.DisplayName, this.PhoneNumber));
}
public HomeController(IPersonService personService, ICityService cityService, IPhoneService phoneService)
{
_personService = personService;
_cityService = cityService;
_phoneService = phoneService;
}
public PhonesController(IPhoneService phoneService)
{
_phoneService = phoneService;
}
public PlayerViewModel(INavigationService navigationService, IPhoneService phoneService)
{
this.navigationService = navigationService;
this.phoneService = phoneService;
}
