public async Task GetCurrentUser()
{
var token = PersistenceProvider.GetToken();
var result = await UserService.GetUser(int.Parse(token.Id));
if (result.Error.Any())
{
RunOnUiThread(() =>
{
ShowToastMessage(Resource.String.ErrorOccurred);
});
return;
}
Entity = result.Data;
RunOnUiThread(() =>
{
if (Entity.Avatar == null)
{
Entity.Avatar = Constants.DefaultBase64PngUserAvatar;
}
Helpers.Helpers.Decode64StringAndSetImage(Entity.Avatar, AccountImage);
AccountName.Text = Entity.FullName;
AccountRole.Text = Entity.Role.ToString();
});
}
public override void OnActivityCreated(Bundle savedInstanceState)
{
base.OnActivityCreated(savedInstanceState);
OnServerProvidedListener = Activity;
OnLoginListener = Activity;
LoginModel = PersistenceProvider.GetCredentials();
if (LoginModel != null)
{
ServerName.Text = LoginModel.ServerName;
Username.Text = LoginModel.Username;
Password.Text = LoginModel.Password;
RememberMe.Checked = LoginModel.RememberMe;
}
else
{
LoginModel = new Models.Login();
}
LoginModel.ServerName = "http://10.0.2.2/MobileWarehouseServer";
LoginModel.Username = "******";
LoginModel.Password = "******";
ServerName.Text = LoginModel.ServerName;
Username.Text = LoginModel.Username;
Password.Text = LoginModel.Password;
}
public void Scenario()
{
var workflowId = Host.StartWorkflow("EventWorkflow", new MyDataClass()
{
StrValue = "0"
}).Result;
int counter = 0;
while ((PersistenceProvider.GetSubcriptions("MyEvent", "0", DateTime.MaxValue).Result.Count() == 0) && (counter < 150))
{
System.Threading.Thread.Sleep(200);
counter++;
}
Host.PublishEvent("MyEvent", "0", "Pass");
var instance = PersistenceProvider.GetWorkflowInstance(workflowId).Result;
counter = 0;
while ((instance.Status == WorkflowStatus.Runnable) && (counter < 150))
{
System.Threading.Thread.Sleep(200);
counter++;
instance = PersistenceProvider.GetWorkflowInstance(workflowId).Result;
}
instance.Status.Should().Be(WorkflowStatus.Complete);
(instance.Data as MyDataClass).StrValue.Should().Be("Pass");
}
/// <summary>
/// Load Next is to be call till HasMoreData is false
/// </summary>
/// <param name="userContext">user object to be fetched in next LoadNext call</param>
/// <returns></returns>
public LoaderResult LoadNext(object userContext)
{
try
{
if (_persistentItems == null)
{
_persistentItems = PersistenceProvider.GetAll(_hint).GetEnumerator();
}
LoaderResult result = new LoaderResult();
result.UserContext = userContext;
result.HasMoreData = false;
while (_persistentItems.MoveNext())
{
result.Data.Add(_persistentItems.Current);
_currentIndex++;
if (_currentIndex % _singleIterationSize == 0)
{
result.HasMoreData = true;
break;
}
}
return(result);
}
catch (Exception ex)
{
Logger.LogError(ex.ToString());
throw ex;
}
}
/// <summary>
/// Initilization of database
/// </summary>
/// <param name="parameters"></param>
/// <param name="cacheId"></param>
public virtual void Init(IDictionary parameters, string cacheId)
{
try
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
if (parameters.Contains("connectionstring"))
{
_connectionString = (string)parameters["connectionstring"];
}
//Connection string for cosmos db must contain a pattren
// ~ separated serviceEndPoint~authKey~databaseName
if (parameters.Contains("FQN"))
{
PersistenceProvider = ReflectionUtil.CreateInstanceWithReflection((string)parameters["FQN"], cacheId);
}
else
{
throw new ArgumentException("FQN");
}
PersistenceProvider.Init(_connectionString);
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
throw ex;
}
}
public void Scenario()
{
var workflowId = Host.StartWorkflow("IfWorkflow", new MyDataClass()
{
Counter = 2
}).Result;
var instance = PersistenceProvider.GetWorkflowInstance(workflowId).Result;
int counter = 0;
while ((instance.Status == WorkflowStatus.Runnable) && (counter < 300))
{
Thread.Sleep(100);
counter++;
instance = PersistenceProvider.GetWorkflowInstance(workflowId).Result;
}
Step1Ticker.Should().Be(1);
Step2Ticker.Should().Be(1);
If1Ticker.Should().Be(1);
If2Ticker.Should().Be(0);
If3Ticker.Should().Be(1);
AfterIfBlock.Should().BeAfter(LastIfBlock);
instance.Status.Should().Be(WorkflowStatus.Complete);
}
private void ModernWindow_Closing(object sender, CancelEventArgs e)
{
var hasModifications = model.AccountGroups.Groups
.Select(g => g.ModificationTracker.ModifiedElements.Any())
.Where(m => m)
.Any();
if (hasModifications)
{
MessageBoxResult r = ModernDialog.ShowMessage(
"Save unsaved changes?",
"Save or Ignore", MessageBoxButton.YesNoCancel, Window.GetWindow(this));
if (r == MessageBoxResult.Yes)
{
UIHelper.WithLongEncryptionDecryptionWarning(
Window.GetWindow(this),
"Saving...",
() => PersistenceProvider.Persist(model.AccountGroups)
);
}
else if (r == MessageBoxResult.Cancel)
{
e.Cancel = true;
}
}
}
public void Scenario()
{
var workflowId = Host.StartWorkflow("HumanWorkflow").Result;
int counter = 0;
while ((Host.GetOpenUserActions(workflowId).Count() == 0) && (counter < 180))
{
System.Threading.Thread.Sleep(200);
counter++;
}
var openItems1 = Host.GetOpenUserActions(workflowId);
Host.PublishUserAction(openItems1.First().Key, "user1", "yes").Wait();
var instance = PersistenceProvider.GetWorkflowInstance(workflowId).Result;
counter = 0;
while ((instance.Status == WorkflowStatus.Runnable) && (counter < 180))
{
System.Threading.Thread.Sleep(200);
counter++;
instance = PersistenceProvider.GetWorkflowInstance(workflowId).Result;
}
var openItems2 = Host.GetOpenUserActions(workflowId);
ApproveStepTicker.Should().Be(1);
DisapproveStepTicker.Should().Be(0);
openItems1.Count().Should().Be(1);
openItems1.First().Options.Count().Should().Be(2);
openItems1.First().Options.Any(x => Convert.ToString(x.Value) == "yes").Should().Be(true);
openItems1.First().Options.Any(x => Convert.ToString(x.Value) == "no").Should().Be(true);
}
private void SaveButton_Click(object sender, RoutedEventArgs e)
{
UIHelper.WithLongEncryptionDecryptionWarning(
Window.GetWindow(this),
"Saving...",
() => PersistenceProvider.Persist(model.AccountGroups)
);
}
public void Container0() //Container method for Id snippet
{
//<snippet10>
FilePersistenceProviderFactory factory = new FilePersistenceProviderFactory();
PersistenceProvider provider = factory.CreateProvider(new Guid());
Guid providerId = provider.Id;
//</snippet10>
}
protected Transaction()
{
InTransaction = true;
DisableForeignKeyChecks = false;
PersistenceProvider factory = PersistenceProvider.CurrentPersistenceProvider;
PersistenceProviderFactory = factory;
}
private void ModernWindow_Loaded(object sender, RoutedEventArgs e)
{
model.AccountGroups = PersistenceProvider.Load();
foreach (var g in model.AccountGroups.Groups)
{
RegisterGroup(g);
}
model.AccountGroups.Groups.CollectionChanged += Groups_CollectionChanged;
}
public ServiceDurableInstance(
PersistenceProvider persistenceProvider,
ServiceDurableInstanceContextProvider contextManager,
bool saveStateInOperationTransaction,
UnknownExceptionAction unknownExceptionAction,
DurableRuntimeValidator runtimeValidator,
TimeSpan operationTimeout)
: this(persistenceProvider, contextManager, saveStateInOperationTransaction, unknownExceptionAction, runtimeValidator, operationTimeout, null)
{
}
protected Transaction()
{
InTransaction = true;
DisableForeignKeyChecks = false;
PersistenceProvider factory = PersistenceProvider.CurrentPersistenceProvider;
PersistenceProviderFactory = factory;
NodePersistenceProvider = factory.NodePersistenceProvider;
RelationshipPersistenceProvider = factory.RelationshipPersistenceProvider;
}
/// <summary>
/// Dispose for the Provider
/// </summary>
public virtual void Dispose()
{
try
{
PersistenceProvider.Dispose();
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
throw ex;
}
}
public void SetDlgInfo(Mediator mediator, IWfiWordform wordform, ParserListener parserListener)
{
m_mediator = mediator;
m_persistProvider = new PersistenceProvider(PersistProviderID, m_mediator.PropertyTable);
m_persistProvider.RestoreWindowSettings(PersistProviderID, this);
m_xampleTrace = new XAmpleTrace(mediator);
m_hermitCrabTrace = new HCTrace(mediator);
m_cache = (FdoCache)m_mediator.PropertyTable.GetValue("cache");
m_parserListener = parserListener;
Text = m_cache.ProjectId.UiName + " - " + Text;
SetRootSite();
SetFontInfo();
if (wordform == null)
{
GetLastWordUsed();
}
else
{
SetWordToUse(wordform.Form.VernacularDefaultWritingSystem.Text);
}
m_webPageInteractor = new WebPageInteractor(m_htmlControl, ParserTrace, m_mediator, m_wordformTextBox);
#if !__MonoCS__
m_htmlControl.Browser.ObjectForScripting = m_webPageInteractor;
#endif
// HermitCrab does not currently support selected tracing
/*if (m_cache.LangProject.MorphologicalDataOA.ActiveParser == "HC")
* {
* m_parserCanDoSelectMorphs = false;
* m_doSelectMorphsCheckBox.Enabled = false;
* }
*/
// No such thing as FwApp.App now: if(FwApp.App != null) // Could be null during testing
if (m_mediator.HelpTopicProvider != null) // trying this
{
m_helpProvider.HelpNamespace = m_mediator.HelpTopicProvider.HelpFile;
m_helpProvider.SetHelpKeyword(this, m_mediator.HelpTopicProvider.GetHelpString(HelpTopicID));
m_helpProvider.SetHelpNavigator(this, HelpNavigator.Topic);
}
if (m_parserListener.Connection != null)
{
m_parserListener.Connection.TryAWordDialogIsRunning = true;
m_statusLabel.Text = GetString("ParserStatusPrefix") + ParserUIStrings.ksIdle_ + GetString("ParserStatusSuffix");
}
else
{
m_statusLabel.Text = ParserStoppedMessage();
}
}
/// <summary>
/// LoadDataTypeFromSource to load data type from source.
/// </summary>
/// <param name="key">key of data type</param>
/// <param name="dataType">type of datatype</param>
/// <returns>It returns the ProviderDataTypeItem IEnerable</returns>
public ProviderDataTypeItem <IEnumerable> LoadDataTypeFromSource(string key, DistributedDataType dataType)
{
try
{
//Data structures are avaialable in ProviderDataTypeItem<IEnumerable>
return((ProviderDataTypeItem <IEnumerable>)PersistenceProvider.Get(new string[] { key })?[key]);
}
catch (Exception e)
{
Logger.LogError(e.Message);
throw e;
}
}
public static void Close()
{
var session = SessionContext.Unbind();
if (session == null)
{
return;
}
TransactionContext.Unbind()?.Dispose();
session.Dispose();
PersistenceProvider.Close();
}
public void Should_return_data_created_in_test_scope()
{
Product product = CreateProduct();
var persistenceProvider = new PersistenceProvider<Product>();
persistenceProvider.Save(product);
var fetchedProducts = new PersistenceProvider<Product>().FetchAll();
Assert.That(fetchedProducts.Count, Is.EqualTo(1));
Assert.That(fetchedProducts[0].Releases.Count(), Is.EqualTo(4));
Assert.That(fetchedProducts[0].Tags.Count(), Is.EqualTo(2));
Assert.That(new PersistenceProvider<Tag>().FetchAll().Count, Is.EqualTo(2));
Assert.That(new PersistenceProvider<Release>().FetchAll().Count, Is.EqualTo(4));
}
public void OnClick(View view)
{
var token = PersistenceProvider.GetToken();
var radioButtonId = LanguagesRadioGroup.CheckedRadioButtonId;
var radioButton = LanguagesRadioGroup.FindViewById <RadioButton>(radioButtonId);
var iso3Language = (string)radioButton.Tag;
PersistenceProvider.SetLanguage(iso3Language);
Activity.SetLanguage(iso3Language);
Activity.StartActivity(Activity.Intent);
Activity.Finish();
}
public static void Open()
{
PersistenceProvider.Open <MySqlAdapter>(ConfigurationManager.AppSettings["ConnectionString"]);
// We override the contexts that use WebSessionContext as that is not available when running unit tests.
SessionContext.SetContext(new StaticContext <ISession>());
TransactionContext.SetContext(new StaticContext <IDbTransaction>());
var session = SessionFactoryContext.Current.OpenSession();
SessionContext.Bind(session);
var transaction = session.Connection.BeginTransaction();
TransactionContext.Bind(transaction);
}
public void Should_return_data_created_in_test_scope()
{
Product product = CreateProduct();
var persistenceProvider = new PersistenceProvider <Product>();
persistenceProvider.Save(product);
var fetchedProducts = new PersistenceProvider <Product>().FetchAll();
Assert.That(fetchedProducts.Count, Is.EqualTo(1));
Assert.That(fetchedProducts[0].Releases.Count(), Is.EqualTo(4));
Assert.That(fetchedProducts[0].Tags.Count(), Is.EqualTo(2));
Assert.That(new PersistenceProvider <Tag>().FetchAll().Count, Is.EqualTo(2));
Assert.That(new PersistenceProvider <Release>().FetchAll().Count, Is.EqualTo(4));
}
protected DatastoreModel(PersistenceProvider persistence)
{
PersistenceProvider = persistence;
Entities = new EntityCollection(this);
Relations = new RelationshipCollection(this);
Interfaces = new InterfaceCollection(this);
Enumerations = new EnumerationCollection(this);
FunctionalIds = new FunctionalIdCollection(this);
SubModels = new SubModelCollection(this);
Labels = new model.LabelCollection();
RelationshipTypes = new model.RelationshipTypeCollection();
DataMigration = new DataMigrationScope(this);
}
/// <summary>
/// Load From Source for provider cache item
/// </summary>
/// <param name="key">key of cacheItem</param>
/// <returns>returns ProviderCacheItem</returns>
public ProviderCacheItem LoadFromSource(string key)
{
try
{
var providerItems = PersistenceProvider.Get(new string[] { key });
if (providerItems.ContainsKey(key))
{
return((ProviderCacheItem)providerItems[key]);
}
return(null);
}
catch (Exception e)
{
Logger.LogError(e.Message);
throw e;
}
}
/// <summary>
/// Load from source for bulk for ProviderCacheItem
/// </summary>
/// <param name="keys">< collection of keys against ProviderCacheItems/param>
/// <returns>returns dictionary of ProviderCacheItem</returns>
public IDictionary <string, ProviderCacheItem> LoadFromSource(ICollection <string> keys)
{
try
{
IDictionary <string, ProviderCacheItem> providerCacheItems = new Dictionary <string, ProviderCacheItem>();
foreach (var providerItem in PersistenceProvider.Get(keys))
{
providerCacheItems.Add(providerItem.Key, (ProviderCacheItem)providerItem.Value);
}
return(providerCacheItems);
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
throw ex;
}
}
/// <summary>
/// Write to datasource overload with datatype operations
/// </summary>
/// <param name="dataTypeWriteOperations">collection of datatype operations</param>
/// <returns></returns>
public ICollection <OperationResult> WriteToDataSource(ICollection <DataTypeWriteOperation> dataTypeWriteOperations)
{
//Implementation is required in order to use data structures
ICollection <OperationResult> dtOperationResults = new List <OperationResult>();
foreach (var dtOperation in dataTypeWriteOperations)
{
OperationResult opResult = new OperationResult(dtOperation, OperationResult.Status.Success, "");
try
{
switch (dtOperation.OperationType)
{
case DatastructureOperationType.CreateDataType:
IDictionary <string, ProviderItemBase> dict = new Dictionary <string, ProviderItemBase>();
dict.Add(dtOperation.Key, dtOperation.ProviderItem);
PersistenceProvider.Insert(dict);
break;
case DatastructureOperationType.DeleteDataType:
PersistenceProvider.Remove(new string[] { dtOperation.Key });
break;
case DatastructureOperationType.AddToDataType:
PersistenceProvider.AddToDataType(dtOperation.Key, dtOperation.ProviderItem, dtOperation.DataType);
break;
case DatastructureOperationType.UpdateDataType:
PersistenceProvider.UpdateToDataType(dtOperation.Key, dtOperation.ProviderItem, dtOperation.DataType);
break;
case DatastructureOperationType.DeleteFromDataType:
PersistenceProvider.RemoveFromDataType(dtOperation.Key, dtOperation.DataType);
break;
}
}
catch (Exception ex)
{
opResult.Exception = ex;
opResult.OperationStatus = OperationResult.Status.Failure;
}
dtOperationResults.Add(opResult);
}
return(dtOperationResults);
}
public void Scenario()
{
var workflowId = Host.StartWorkflow("BasicWorkflow").Result;
var instance = PersistenceProvider.GetWorkflowInstance(workflowId).Result;
int counter = 0;
while ((instance.Status == WorkflowStatus.Runnable) && (counter < 300))
{
System.Threading.Thread.Sleep(100);
counter++;
instance = PersistenceProvider.GetWorkflowInstance(workflowId).Result;
}
instance.Status.Should().Be(WorkflowStatus.Complete);
Step1Ticker.Should().Be(1);
Step2Ticker.Should().Be(1);
}
protected override ServiceOutcome DoWork()
{
Delivery delivery = Delivery.Get(Instance.ParentInstance);
foreach (DeliveryFile file in delivery.Files)
{
using (PersistenceProvider.Open("otlp"))
{
using (DeliveryFileReader <PpcRow> reader = file.OpenReader())
{
while (reader.Read())
{
}
}
}
}
}
public void SetDlgInfo(Mediator mediator, PropertyTable propertyTable, IWfiWordform wordform, ParserListener parserListener)
{
Mediator = mediator;
PropTable = propertyTable;
m_persistProvider = new PersistenceProvider(Mediator, propertyTable, PersistProviderID);
m_cache = PropTable.GetValue <LcmCache>("cache");
m_parserListener = parserListener;
Text = m_cache.ProjectId.UiName + " - " + Text;
SetRootSite();
SetFontInfo();
// restore window location and size after setting up the form textbox, because it might adjust size of
// window causing the window to grow every time it is opened
m_persistProvider.RestoreWindowSettings(PersistProviderID, this);
if (wordform == null)
{
GetLastWordUsed();
}
else
{
SetWordToUse(wordform.Form.VernacularDefaultWritingSystem.Text);
}
m_webPageInteractor = new WebPageInteractor(m_htmlControl, Mediator, m_cache, m_wordformTextBox);
// No such thing as FwApp.App now: if(FwApp.App != null) // Could be null during testing
var helpTopicProvider = PropTable.GetValue <IHelpTopicProvider>("HelpTopicProvider");
if (helpTopicProvider != null) // trying this
{
m_helpProvider.HelpNamespace = helpTopicProvider.HelpFile;
m_helpProvider.SetHelpKeyword(this, helpTopicProvider.GetHelpString(HelpTopicID));
m_helpProvider.SetHelpNavigator(this, HelpNavigator.Topic);
}
if (m_parserListener.Connection != null)
{
m_parserListener.Connection.TryAWordDialogIsRunning = true;
m_statusLabel.Text = GetString("ParserStatusPrefix") + ParserUIStrings.ksIdle_ + GetString("ParserStatusSuffix");
}
else
{
m_statusLabel.Text = ParserStoppedMessage();
}
}
public void Scenario()
{
var workflowId = Host.StartWorkflow("OutcomeFork").Result;
var instance = PersistenceProvider.GetWorkflowInstance(workflowId).Result;
int counter = 0;
while ((instance.Status == WorkflowStatus.Running) && (counter < 300))
{
System.Threading.Thread.Sleep(100);
counter++;
instance = PersistenceProvider.GetWorkflowInstance(workflowId).Result;
}
instance.Status.Should().Be(WorkflowStatus.Complete);
TaskATicker.Should().Be(1);
TaskBTicker.Should().Be(0);
TaskCTicker.Should().Be(1);
}
/// <summary>
/// 删除
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public virtual async Task DeleteAsync(string id)
{
var entity = await _workflowDefinitionRepository.GetAsync(id);
var all = await PersistenceProvider.GetAllRunnablePersistedWorkflow(entity.Id, entity.Version);
if (all.Count() > 0)
{
throw new UserFriendlyException("删不了！！还有没有执行完的流程！");
}
if (_registry.IsRegistered(entity.Id.ToString(), entity.Version))
{
_registry.DeregisterWorkflow(entity.Id.ToString(), entity.Version);
}
await _workflowDefinitionRepository.DeleteAsync(entity);
}
