private Maybe<IDocumentIndex> DoGetDocumentFinder(AccountName accountName, DocumentIndexTypeToken documentIndexTypeToken)
{
Lazy<IDocumentIndex> fetched;
return _documentIndexes[documentIndexTypeToken].TryGetValue(accountName.Value, out fetched)
? Maybe.Return(fetched.Value)
: Maybe.Nothing;
}
public ProfileGateway(IProfileReadonly profile, AccountName accountName, ITpBus bus)
{
_profile = profile;
_accountName = accountName;
_bus = bus;
_storage = _profile.Get<ITargetProcessMessage>();
}
public IEnumerable<Profile> GetAll(AccountName accountName)
{
using (var context = CreateDataContext())
{
return SelectAccount(context.Accounts, accountName).Single().Profiles;
}
}
public MashupDto GetMashup(AccountName account, string mashupName)
{
_log.Info(string.Format("Getting mashup with name '{0}'", mashupName));
string mashupFolderPath = GetMashupFolderPath(account, mashupName);
if (!Directory.Exists(mashupFolderPath))
{
return null;
}
var script = Directory.GetFiles(mashupFolderPath, "*.js");
var config = Directory.GetFiles(mashupFolderPath, MashupDto.PlaceholdersCfgFileName);
if (!script.Any())
{
return null;
}
var scriptFileInfo = new FileInfo(script.First());
var mashup = CreateMashupDto(config, scriptFileInfo);
_log.Info(string.Format("Mashup with name '{0}' retrieved", mashupName));
return mashup;
}
public Mashup GetMashup(AccountName account, string mashupName)
{
_log.Info(string.Format("Getting mashup with name '{0}'", mashupName));
Mashup mashup = _mashupLoader.Load(GetMashupFolderPath(account, mashupName), mashupName);
_log.Info(string.Format("Mashup with name '{0}' retrieved", mashupName));
return mashup;
}
public MashupScriptStorage(IPluginContext context, IMashupLocalFolder folder, ILogManager logManager, IMashupLoader mashupLoader)
{
_folder = folder;
_mashupLoader = mashupLoader;
_log = logManager.GetLogger(GetType());
_accountName = context.AccountName;
}
public void WriteOnceReadTwice()
{
int beforeProfileAdd = 0;
int afterProfileAdded = 0;
var account1Name = new AccountName("account1");
AccountCollection.GetOrCreate(account1Name);
ExecuteConcurrently(() =>
{
Interlocked.Increment(ref beforeProfileAdd);
IAccount account = AccountCollection.GetOrCreate(account1Name);
account.Profiles.Add(new ProfileCreationArgs(new ProfileName("~"), new object()));
Interlocked.Increment(ref afterProfileAdded);
}, () =>
{
var accountFirstVersion = AccountCollection.GetOrCreate(account1Name);
var accountSecondVersion = AccountCollection.GetOrCreate(account1Name);
bool sameVersion = false;
if (Interlocked.Increment(ref beforeProfileAdd) == 1)
{
sameVersion = (accountFirstVersion == accountSecondVersion);
sameVersion.Should(Be.True, "sameVersion.Should(Be.True)");
}
if (Interlocked.Increment(ref afterProfileAdded) == 2)
{
IAccount latestAccountVersion = AccountCollection.GetOrCreate(account1Name);
latestAccountVersion.Profiles.Count().Should(Be.EqualTo(1), "latestAccountVersion.Profiles.Count().Should(Be.EqualTo(1))");
if (sameVersion)
{
(latestAccountVersion == accountFirstVersion).Should(Be.False, "(latestAccountVersion == accountFirstVersion).Should(Be.False)");
}
}
});
AccountCollection.GetOrCreate(account1Name).Profiles.Count().Should(Be.EqualTo(1), "AccountCollection.GetOrCreate(account1Name).Profiles.Count().Should(Be.EqualTo(1))");
}
public Profile Update(ProfileName profileName, bool initialized, AccountName accountName)
{
var index = _profiles[accountName].FindIndex(x => x.Name == profileName.Value);
_profiles[accountName][index].Initialized = initialized;
_profiles[accountName][index].Name = profileName.Value;
return _profiles[accountName][index];
}
public ContextQueryPlanBuilder(IDocumentIndexProvider documentIndexProvider, IDocumentIdFactory documentIdFactory, AccountName accountName, IProfileReadonly profile, IEntityTypeProvider entityTypeProvider)
{
_documentIndexProvider = documentIndexProvider;
_documentIdFactory = documentIdFactory;
_accountName = accountName;
_profile = profile;
_entityTypeProvider = entityTypeProvider;
}
public static void ShutdownDocumentIndexesIfRunning(this IDocumentIndexProvider documentIndexProvider, AccountName accountName, DocumentIndexShutdownSetup setup)
{
IEnumerable<IDocumentIndex> documentIndexes = documentIndexProvider.DocumentTypes.Select(t => documentIndexProvider.GetDocumentIndex(accountName, t)).Choose();
foreach (IDocumentIndex documentIndex in documentIndexes)
{
documentIndex.Shutdown(setup);
}
}
public ProfileDomainObject Create(Profile profile, AccountName accountName)
{
return new ProfileDomainObject(profile.Name, accountName, profile.Initialized, _pluginMetadata.ProfileType)
{
EventAggregator = _eventAggregator,
ProfileRepository = this,
StorageRepository = new ProfileStorageRepository(new ProfileId(profile.Id), _profileStoragePersister, _pluginMetadata)
};
}
public void Delete(ProfileName profileName, AccountName accountName)
{
using (var context = CreateDataContext())
{
var profile = SelectProfile(context.Accounts, profileName, accountName);
context.Profiles.DeleteOnSubmit(profile);
context.SubmitChanges();
}
}
public QueryPlanBuilder(IPluginContext pluginContext, IProfileReadonly profile, IDocumentIndexProvider documentIndexProvider, IEntityTypeProvider entityTypeProvider, IDocumentIdFactory documentIdFactory)
{
_accountName = pluginContext.AccountName;
_profile = profile;
_documentIndexProvider = documentIndexProvider;
_entityTypeProvider = entityTypeProvider;
_documentIdFactory = documentIdFactory;
_contextQueryPlanBuilder = new ContextQueryPlanBuilder(_documentIndexProvider, _documentIdFactory, pluginContext.AccountName, _profile, _entityTypeProvider);
}
public void RemoveAccount()
{
var accountName = new AccountName("Account");
_accountCollection.GetOrCreate(accountName);
Assert.IsTrue(_accountCollection.Any(c => c.Name == accountName.Value));
_accountHandler.Handle(new AccountRemovedMessage(accountName.Value));
_accountHandler.Handle(_bus.PluginCommands.OfType<AccountRemovedLastStepMessage>().Single());
Assert.IsFalse(_accountCollection.Any(c => c.Name == accountName.Value));
}
public void Dispose()
{
if (_disposed) return;
_disposed = true;
_accountName = null;
_bus = null;
_storage = null;
}
public IAccount GetOrCreate(AccountName accountName)
{
IAccount account;
if(_accounts.TryGetValue(accountName, out account))
{
return account;
}
return _accounts[accountName] = new AccountDomainObject(accountName, new ProfileCollection(accountName, new ProfileDomainObject[0]));
}
internal static PluginAccount CreatePluginAccount(PluginName pluginName, AccountName accountName,
PluginProfile[] pluginProfiles)
{
return new PluginAccount
{
PluginName = pluginName,
Name = accountName,
PluginProfiles = pluginProfiles
};
}
public AccountDomainObject GetBy(AccountName accountName)
{
var account = _accountPersister.GetBy(accountName);
if(account == null)
{
return null;
}
return CreateAccount(account);
}
private AccountDomainObject CreateAccount(AccountName accountName, IEnumerable<Profile> profiles)
{
var profileDomainObjects = profiles.Select(p => _profileFactory.Create(p, accountName)).ToList();
var profileCollection = new ProfileCollection(accountName, profileDomainObjects)
{
EventAggregator = _eventAggregator,
ProfileRepository = _profileRepository
};
return new AccountDomainObject(accountName, profileCollection);
}
public PluginMashupMessage CreatePluginMashupMessage(AccountName accountName)
{
return new PluginMashupMessage
{
MashupName = GetMashupName(accountName),
Placeholders = GetPlaceholders(),
PluginMashupScripts = GetMashupScripts(),
PluginName = string.Empty
};
}
public Account GetBy(AccountName accountName)
{
using (var context = CreateDataContext())
{
var dataLoadOptions = new DataLoadOptions();
dataLoadOptions.LoadWith<Account>(a => a.Profiles);
context.LoadOptions = dataLoadOptions;
return context.Accounts.Single(x => x.Plugin.Name == _pluginName && x.Name == accountName.Value);
}
}
public Profile Update(ProfileName profileName, bool initialized, AccountName accountName)
{
using (var context = CreateDataContext())
{
var profileToUpdate = SelectProfile(context.Accounts, profileName, accountName);
profileToUpdate.Initialized = initialized;
context.SubmitChanges();
return profileToUpdate;
}
}
public ProfileDomainObject(ProfileDomainObject other):base(other)
{
_profileName = other._profileName;
_accountName = other._accountName;
_profileSettingsType = other._profileSettingsType;
Initialized = other.Initialized;
_settings = null;
EventAggregator = other.EventAggregator;
ProfileRepository = other.ProfileRepository;
}
public IEnumerable<int> GetVersions(AccountName accountName, DocumentIndexSetup documentIndexSetup)
{
string folder = GetFileFolder(accountName, documentIndexSetup);
string versionedFilenameMask = _documentIndexDataTypeService.CreateVersionedFilenameMask(_fileName);
return _fileService.GetFiles(folder, versionedFilenameMask)
.Select(name => _documentIndexDataTypeService.ParseVersion(new FileInfo(name).Name))
.Choose()
.Distinct()
.ToList();
}
public void Remove(AccountName accountName)
{
var account = _accounts.FirstOrDefault(x => x.Name == accountName);
if (account == null)
{
return;
}
RemoveProfiles(account);
}
public ProfileDomainObject(ProfileName profileName, AccountName accountName, bool initialized, Type profileSettingsType)
{
_profileName = profileName;
_accountName = accountName;
_profileSettingsType = profileSettingsType;
Initialized = initialized;
_settings = null;
EventAggregator = null;
ProfileRepository = null;
}
public Account GetBy(AccountName accountName)
{
var account = _accounts.FirstOrDefault(x => x.Name == accountName);
if(account == null)
{
return null;
}
LoadProfiles(account);
return account;
}
public void RemoveAccount(RoutableTransportMode mode, bool isQueueDelete)
{
_msmqTransport.RoutableTransportMode = mode;
var accountName = new AccountName("Account");
_accountCollection.GetOrCreate(accountName);
Assert.IsTrue(_accountCollection.Any(c => c.Name == accountName.Value));
_accountHandler.Handle(new AccountRemovedMessage(accountName.Value));
_accountHandler.Handle(_bus.PluginCommands.OfType<AccountRemovedLastStepMessage>().Single());
Assert.IsFalse(_accountCollection.Any(c => c.Name == accountName.Value));
Assert.AreEqual(_msmqTransport.IsQueueDeleted, isQueueDelete);
}
public Account Add(AccountName accountName)
{
using (var context = CreateDataContext())
{
var newAccount = new Account {Name = accountName.Value};
var plugin = context.Plugins.Single(x => x.Name == _pluginName);
plugin.Accounts.Add(newAccount);
context.SubmitChanges();
return newAccount;
}
}
public Profile Add(ProfileName profileName, bool initialized, AccountName accountName)
{
using (var context = CreateDataContext())
{
var profiles = SelectAccount(context.Accounts, accountName).Single().Profiles;
var profileToSave = new Profile {Name = profileName.Value, Initialized = initialized};
profiles.Add(profileToSave);
context.SubmitChanges();
return profileToSave;
}
}
public bool Equals(AccountName other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return(Equals(other.Value, Value));
}
