public override void Load(RecordReader creator)
{
Guid = creator.Read_guid();
Adres = creator.Read_string();
Typ = (RepositoryType)creator.Read_int();
Opis = creator.Read_string();
}
public async Task <IHttpActionResult> PutRepositoryType(int id, RepositoryType repositoryType)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != repositoryType.Id)
{
return(BadRequest());
}
db.Entry(repositoryType).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RepositoryTypeExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public RepositoryFactory(RepositoryType type)
{
(Container = new ServiceContainer())
.Register(a => CONNECTION_STRING);
switch (type)
{
case RepositoryType.Dapper:
Container.Register <IPeopleRepository, DapperImplementation.PeopleRepository>();
Container.Register <IAnimalsRepository, DapperImplementation.AnimalsRepository>();
break;
case RepositoryType.InMemory:
Container.Register <IPeopleRepository, InMemoryImplementation.PeopleRepository>();
Container.Register <IAnimalsRepository, InMemoryImplementation.AnimalsRepository>();
break;
case RepositoryType.ADO:
Container.Register <IPeopleRepository, AdoImplementation.PeopleRepository>();
Container.Register <IAnimalsRepository, AdoImplementation.AnimalsRepository>();
break;
case RepositoryType.EntityFramework:
Container.Register <EntityFrameworkImplementation.DataContext>(new PerContainerLifetime());
Container.Register <IPeopleRepository, EntityFrameworkImplementation.PeopleRepository>();
Container.Register <IAnimalsRepository, EntityFrameworkImplementation.AnimalsRepository>();
break;
default:
throw new ArgumentException("Invalid type.", "type");
}
}
public PackageKeyDiff(DiffType diffType, PackageKey newPackageKey, PackageKey oldPackageKey, RepositoryType packageType)
: base(newPackageKey.PackageId, newPackageKey.Version, newPackageKey.Framework)
{
DiffType = diffType;
OldPackageKey = oldPackageKey;
PackageType = packageType;
}
public ExportRepositoryHandler(RepositoryType repositoryType, object[] elements, Catalogue catalogue, IWin32Window parent)
{
_repositoryType = repositoryType;
_elements = elements;
_catalogue = catalogue;
_parent = parent;
}
public IRepository EnsureRepository(RepositoryType repositoryType)
{
if (repositoryType == RepositoryType.Mercurial)
{
if (IsGitRepository)
{
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, Resources.Error_MismatchRepository, repositoryType, RepositoryType.Git, _environment.RepositoryPath));
}
FileSystemHelpers.EnsureDirectory(_environment.RepositoryPath);
var hgRepository = new HgRepository(_environment.RepositoryPath, _environment.SiteRootPath, _settings, _traceFactory);
if (!hgRepository.Exists)
{
hgRepository.Initialize();
}
return hgRepository;
}
else
{
if (IsHgRepository)
{
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, Resources.Error_MismatchRepository, repositoryType, RepositoryType.Mercurial, _environment.RepositoryPath));
}
var gitRepository = new GitExeRepository(_environment.RepositoryPath, _environment.SiteRootPath, _settings, _traceFactory);
if (!gitRepository.Exists)
{
gitRepository.Initialize();
}
return gitRepository;
}
}
public static void AddRepositories(this IServiceCollection services, IConfiguration configuration)
{
string connectionString = configuration.GetConnectionString("DefaultConnection");
var repositoryType = configuration.GetSection("Dapper");
RepositoryType key = (RepositoryType)Enum.Parse(typeof(RepositoryType), repositoryType.Key);
services.AddDbContext <GameContext>(options => options.UseSqlServer(connectionString, b => b.MigrationsAssembly("DataAccessLayer")));
if (key == RepositoryType.Dapper)
{
services.AddTransient <IGameRepository>(provider => new DapperGameRepository(connectionString));
services.AddTransient <ICardRepository>(provider => new DapperCardRepository(connectionString));
services.AddTransient <IMoveRepository>(provider => new DapperMoveRepository(connectionString));
services.AddTransient <IRoundRepository>(provider => new DapperRoundRepository(connectionString));
services.AddTransient <IUserRepository>(provider => new DapperUserRepository(connectionString));
services.AddTransient <IUserGamesRepository>(provider => new DapperUserGamesRepository(connectionString));
services.AddTransient <IUserRoundRepository>(provider => new DapperUserRoundRepository(connectionString));
}
if (key == RepositoryType.EF)
{
services.AddTransient <IGameRepository, GameRepository>();
services.AddTransient <ICardRepository, CardRepository>();
services.AddTransient <IMoveRepository, MoveRepository>();
services.AddTransient <IRoundRepository, RoundRepository>();
services.AddTransient <IUserRepository, UserRepository>();
services.AddTransient <IUserGamesRepository, UserGamesRepository>();
services.AddTransient <IUserRoundRepository, UserRoundRepository>();
}
}
public List <dtoDisplayRepositoryItem> GetAvailableRepositoryItems(
liteRepositorySettings settings,
Int32 idCurrentPerson,
RepositoryType type,
Int32 idCommunity,
String unknownUser,
Dictionary <FolderType, String> fTranslations,
Dictionary <ItemType, String> iTranslations,
ModuleRepository permissions,
Boolean forAdmin = false,
Boolean alsoHidden = false,
Boolean onlyFolder = false,
Boolean useCache = true)
{
return(GetAvailableRepositoryItems(
settings,
idCurrentPerson,
RepositoryIdentifier.Create(type, idCommunity),
unknownUser,
fTranslations,
iTranslations,
permissions,
forAdmin,
alsoHidden,
onlyFolder,
useCache));
}
public void CreateRepository(RepositoryType type)
{
RepositoryType currentType = GetRepositoryType();
if (currentType != RepositoryType.None)
{
throw new InvalidOperationException("Repository already exists. Delete it before creating a new one.");
}
Directory.CreateDirectory(_path);
switch (type)
{
case RepositoryType.Git:
using (var repository = new HybridGitRepository(_path))
{
repository.Initialize();
}
break;
case RepositoryType.Mercurial:
new HgRepository(_path).Initialize();
break;
default:
throw new InvalidOperationException("Unsupported repository type.");
}
}
public IRepository EnsureRepository(RepositoryType repositoryType)
{
// Validate if conflicting with existing repository
RepositoryType existingType;
if (TryGetExistingRepositoryType(out existingType) && existingType != repositoryType)
{
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, Resources.Error_MismatchRepository, repositoryType, existingType, _environment.RepositoryPath));
}
IRepository repository;
if (repositoryType == RepositoryType.None)
{
repository = new NullRepository(_environment, _traceFactory, _httpContext);
}
else if (repositoryType == RepositoryType.Mercurial)
{
FileSystemHelpers.EnsureDirectory(_environment.RepositoryPath);
repository = new HgRepository(_environment.RepositoryPath, _environment.RootPath, _settings, _traceFactory);
}
else
{
repository = CreateGitRepositoryInstance();
}
if (!repository.Exists)
{
repository.Initialize();
}
return repository;
}
public bool SaveFileDialog(string Path)
{
SaveFileDialog saveFileDialog = new SaveFileDialog();
string path = System.Reflection.Assembly.GetExecutingAssembly().GetName().CodeBase;
path = System.IO.Path.GetDirectoryName(path);
path += Path;
saveFileDialog.InitialDirectory = path;
saveFileDialog.Filter = "TXT Files (*.txt)|*.txt|Binary Files (*.dat)|*.dat";
if (saveFileDialog.ShowDialog() == true)
{
FilePath = saveFileDialog.FileName;
string[] words = FilePath.Split('.');
switch (words[1])
{
case "txt": TypeOfReposirory = RepositoryType.TEXT; break;
case "dat": TypeOfReposirory = RepositoryType.BINARY; break;
}
return(true);
}
return(false);
}
public static IFileRepository BuildSourceRepository(XmlNode opNode)
{
IFileRepository sourceRepository = null;
XmlNode sourceNode = Helper.GetSourceNodeForOperation(opNode);
string username = null;
string password = null;
Helper.GetSourceUsernameAndPassword(opNode, out username, out password);
string fullPattern = Helper.GetFilePatternForOperation(opNode);
OperationFileType operationFileType = Helper.GetFileTypeForOperation(opNode);
string rawURL = Helper.GetSourceUrl(sourceNode);
RepositoryType type = Helper.GetRepositoryType(rawURL);
switch (type)
{
case RepositoryType.Disk:
sourceRepository = new DiskFileRepository(null, Helper.GetSourceUrl(sourceNode), username, password, fullPattern, operationFileType);
break;
case RepositoryType.Ftp:
sourceRepository = new FtpFileRepository(null, Helper.GetSourceUrl(sourceNode), username, password, fullPattern, operationFileType);
break;
case RepositoryType.None:
default:
throw new ArgumentException(string.Format("Unknown repository url: {0}",
Helper.GetSourceUrl(sourceNode)));
}
return(sourceRepository);
}
public ISchedulingRepository GetRepository(IDataDomainRequest request, RepositoryType type)
{
try
{
ISchedulingRepository repo = null;
switch (type)
{
case RepositoryType.ToDo:
{
repo = new StubMongoToDoRepository(request.ContractNumber);
break;
}
case RepositoryType.Schedule:
{
repo = new StubMongoScheduleRepository(request.ContractNumber);
break;
}
}
repo.UserId = request.UserId;
return(repo);
}
catch (Exception ex)
{
throw ex;
}
}
public static RepositoryIdentifier Create(RepositoryType type, Int32 idCommunity)
{
return(new RepositoryIdentifier()
{
Type = type, IdCommunity = (type == RepositoryType.Community ? idCommunity : 0)
});
}
public RepositoryFactory(IOptions <WordzzSettings> settings, ILogger logger)
{
_settings = settings.Value;
_logger = logger;
_repositoryType = (RepositoryType)Enum.Parse(typeof(RepositoryType), _settings.Db.DbType);
}
public DropboxInfo(JObject payload, RepositoryType repositoryType)
{
Deployer = DropboxHelper.Dropbox;
DeployInfo = payload.ToObject<DropboxDeployInfo>();
RepositoryType = repositoryType;
IsReusable = false;
}
public IMongoPatientNoteRepository GetRepository(RepositoryType type)
{
try
{
IMongoPatientNoteRepository repo = null;
switch (type)
{
case RepositoryType.PatientNote:
{
repo = new MongoPatientNoteRepository <PatientNoteMongoContext>(_context)
{
UserId = _userId, ContractDBName = _contract
};
break;
}
case RepositoryType.Utilization:
{
repo = new MongoPatientUtilizationRepository <PatientNoteMongoContext>(_context)
{
UserId = _userId, ContractDBName = _contract
};
break;
}
}
return(repo);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Reads the SCM repository provider information from the registry
/// </summary>
private void ReadProviderRegistry()
{
IAnkhPackage ankhPackage = GetService <IAnkhPackage>();
if (ankhPackage != null)
{
using (RegistryKey key = ankhPackage.ApplicationRegistryRoot)
{
using (RegistryKey aKey = key.OpenSubKey("ScmRepositoryProviders"))
{
if (aKey == null)
{
return;
}
string[] providerKeys = aKey.GetSubKeyNames();
foreach (string providerKey in providerKeys)
{
using (RegistryKey provider = aKey.OpenSubKey(providerKey))
{
string serviceName = (string)provider.GetValue("");
RepositoryType rt = GetRepositoryType(provider.GetValue("ScmType") as string);
ScmRepositoryProvider descriptor = new ScmRepositoryProviderProxy(this, providerKey, serviceName, rt);
if (!_nameProviderMap.ContainsKey(providerKey))
{
_nameProviderMap.Add(providerKey, descriptor);
}
}
}
}
}
}
}
public IRepository EnsureRepository(RepositoryType repositoryType)
{
// Validate if conflicting with existing repository
RepositoryType existingType;
if (TryGetExistingRepositoryType(out existingType) && existingType != repositoryType)
{
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, Resources.Error_MismatchRepository, repositoryType, existingType, _environment.RepositoryPath));
}
IRepository repository;
if (repositoryType == RepositoryType.None)
{
repository = new NullRepository(_environment, _traceFactory);
}
else if (repositoryType == RepositoryType.Mercurial)
{
FileSystemHelpers.EnsureDirectory(_environment.RepositoryPath);
repository = new HgRepository(_environment.RepositoryPath, _environment.RootPath, _settings, _traceFactory);
}
else
{
repository = CreateGitRepositoryInstance();
}
if (!repository.Exists)
{
repository.Initialize();
}
return(repository);
}
public IRepositoryService RetrieveObject_Old(RepositoryType type, string url)
{
IRepositoryService factoryObject;
//string[] splitUrl = url.Split('/');
//string Type = splitUrl[0].ToString();
switch (type)
{
case RepositoryType.AzureDevops:
string[] splitAzureUrl = url.Split('/');
factoryObject = new AzureDevopsService()
{
organizationName = splitAzureUrl[1].ToString(),
projectName = splitAzureUrl[3].ToString()
};
break;
case RepositoryType.Git:
string[] splitGitUrl = url.Split('/');
factoryObject = new GitService()
{
url = url,
organizationName = splitGitUrl[1].ToString(),
projectName = splitGitUrl[2].ToString(),
};
break;
default:
factoryObject = null;
break;
}
return(factoryObject);
}
private static void StartServer()
{
repositoryType = ConfigHelper.GetRepositorySetting();
generatorType = ConfigHelper.GetGeneratorSetting();
Console.WriteLine("Initializing system...");
system = Factory.GenerateOMS(repositoryType, generatorType);
Console.WriteLine("System ready.");
Console.WriteLine("Creating connection...");
connection = new Connection(system);
Console.WriteLine("Connection ready.");
Console.WriteLine("Starting server...");
bool result = connection.Open();
if (result)
{
Console.WriteLine("Server online.");
Console.ReadKey(true);
Console.WriteLine("Shutting down server...");
connection.Close();
Console.WriteLine("Server offline.");
}
else
{
Console.WriteLine("Server failed to start.");
Console.ReadKey(true);
}
}
private static String BaseParameters(RepositoryType type, Int32 idCommunity, long idItem = long.MinValue, long idFolder = long.MinValue, FolderType folderType = FolderType.none, OrderBy orderBy = OrderBy.none, Boolean?ascending = null, Boolean withPlaceHolders = false)
{
return("type=" + type.ToString() + ((idCommunity > -1) ? "&idCommunity=" + idCommunity.ToString() : "")
+ BaseParameters(false, idItem, idFolder)
+ ((folderType != FolderType.none) ? "&ftype=" + folderType.ToString() : "")
+ BaseDisplayParameters(withPlaceHolders, orderBy, ascending));
}
public void ShouldCreateRepositoriesBasedOnParameter(RepositoryType repositoryType, Type expectedType, string path)
{
var target = _repositoryFactory.Create(repositoryType, path);
Assert.NotNull(target);
Assert.IsType(expectedType, target);
}
public DropboxInfo(JObject payload, RepositoryType repositoryType)
{
Deployer = DropboxHelper.Dropbox;
DeployInfo = payload.ToObject <DropboxDeployInfo>();
RepositoryType = repositoryType;
IsReusable = false;
}
public bool OpenFileDialog(string Path)
{
OpenFileDialog openFileDialog = new OpenFileDialog();
string path = System.Reflection.Assembly.GetExecutingAssembly().GetName().CodeBase;
path = System.IO.Path.GetDirectoryName(path);
path += Path;
openFileDialog.InitialDirectory = path;
openFileDialog.CheckFileExists = true;
openFileDialog.Multiselect = false;
openFileDialog.Filter = "All Files(*.*)|*.*|TXT Files (*.txt)|*.txt|Binary Files (*.dat)|*.dat";
if (openFileDialog.ShowDialog() == true)
{
FilePath = openFileDialog.FileName;
string[] words = FilePath.Split('.');
switch (words[1])
{
case "txt": TypeOfReposirory = RepositoryType.TEXT; break;
case "dat": TypeOfReposirory = RepositoryType.BINARY; break;
}
return(true);
}
return(false);
}
/// <summary>
/// Format DB specific by removing unnecessary DB specific string parts.
/// </summary>
/// <param name="sql"></param>
/// <returns></returns>
//#DB=Asa# DB specif SQL for Asa
//#DB=FIREBIRD# DB specif SQL for FIREBIRD
//#DB=JET# DB specif SQL for JET
//#DB=MySql# DB specif SQL for My SQL
//#DB=ACCESS2007# DB specif SQL for ACCESS2007
//#DB=ORACLE# DB specif SQL for Oracle
//#DB=POSTGRES# DB specif SQL for POSTGRES
//#DB=SqlSvr# DB specif SQL for SQL Server
string FormatSqldBspecific(string sql)
{
// available DBs
var dbs = new Dictionary <RepositoryType, string>()
{
{ RepositoryType.Access2007, "#DB=ACCESS2007#" },
{ RepositoryType.Asa, "#DB=Asa#" },
{ RepositoryType.Firebird, "#DB=FIREBIRD#" },
{ RepositoryType.AdoJet, "#DB=JET#" },
{ RepositoryType.MySql, "#DB=MySql#" },
{ RepositoryType.Oracle, "#DB=ORACLE#" },
{ RepositoryType.Postgres, "#DB=POSTGRES#" },
{ RepositoryType.SqlSvr, "#DB=SqlSvr#" },
};
RepositoryType dbType = GetRepositoryType();
string s = sql;
foreach (var curDb in dbs)
{
if (curDb.Key != dbType)
{ // delete not used DBs
string delete = $"{curDb.Value}.*?{curDb.Value}";
s = Regex.Replace(s, delete, "", RegexOptions.Multiline | RegexOptions.IgnoreCase);
}
}
// delete remaining DB identifying string
s = Regex.Replace(s, @"#DB=(Asa|FIREBIRD|JET|MySql|ORACLE|ACCESS2007|POSTGRES|SqlSvr)#", "", RegexOptions.Multiline | RegexOptions.IgnoreCase);
// delete multiple empty lines
for (int i = 0; i < 4; i++)
{
s = Regex.Replace(s, "\r\n\r\n", "", RegexOptions.Multiline | RegexOptions.IgnoreCase);
}
return(s);
}
public bool SaveFileDialog(string Path, RepositoryType type)
{
SaveFileDialog saveFileDialog = new SaveFileDialog();
string path = System.Reflection.Assembly.GetExecutingAssembly().GetName().CodeBase;
path = System.IO.Path.GetDirectoryName(path);
path += Path;
saveFileDialog.InitialDirectory = path;
if (type is RepositoryType.BINARY)
{
saveFileDialog.Filter = "Binary Files (*.dat)|*.dat";
}
if (type is RepositoryType.TEXT)
{
saveFileDialog.Filter = "TXT Files (*.txt)|*.txt";
}
if (saveFileDialog.ShowDialog() == true)
{
FilePath = saveFileDialog.FileName;
return(true);
}
return(false);
}
/// <summary>
/// Retrieves MethodInfo for Queryable Filter on the Entity with the specified parameterType, returns null if none exists
/// </summary>
/// <param name="parameterType"></param>
/// <returns></returns>
public MethodInfo RepositoryQueryableFilterMethod(Type parameterType)
{
MethodInfo method = null;
bool exists = false;
if (_repositoryQueryableFilterMethod == null)
{
_repositoryQueryableFilterMethod = new Dictionary <Type, MethodInfo>();
}
else
{
exists = _repositoryQueryableFilterMethod.TryGetValue(parameterType, out method);
}
if (!exists)
{
method = RepositoryType.GetMethod("Filter", new Type[] { QueryableType, parameterType });
if (method != null && method.GetParameters()[0].ParameterType.GetGenericTypeDefinition() != typeof(IQueryable <>))
{
method = null;
}
_repositoryQueryableFilterMethod.Add(parameterType, method);
}
return(method);
}
public IPatientRepository GetRepository(IDataDomainRequest request, RepositoryType type)
{
IPatientRepository repo = null;
switch (type)
{
case RepositoryType.Patient:
{
repo = new MongoPatientRepository(request.ContractNumber) as IPatientRepository;
break;
}
case RepositoryType.CohortPatientView:
{
repo = new MongoCohortPatientViewRepository(request.ContractNumber)
{
Utils = new DTOUtils()
} as IPatientRepository;
break;
}
case RepositoryType.PatientUser:
{
repo = new MongoPatientUserRepository(request.ContractNumber) as IPatientRepository;
break;
}
}
repo.UserId = request.UserId;
return(repo);
}
public IRepository EnsureRepository(RepositoryType repositoryType)
{
IRepository repository;
if (repositoryType == RepositoryType.Mercurial)
{
if (IsGitRepository)
{
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, Resources.Error_MismatchRepository, repositoryType, RepositoryType.Git, _environment.RepositoryPath));
}
FileSystemHelpers.EnsureDirectory(_environment.RepositoryPath);
repository = new HgRepository(_environment.RepositoryPath, _environment.SiteRootPath, _settings, _traceFactory);
}
else
{
if (IsHgRepository)
{
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, Resources.Error_MismatchRepository, repositoryType, RepositoryType.Mercurial, _environment.RepositoryPath));
}
repository = new GitExeRepository(_environment, _settings, _traceFactory);
}
if (!repository.Exists)
{
repository.Initialize();
}
return(repository);
}
internal IEnumerable <PreinstalledPackageConfiguration> GetConfigurationsFromXmlDocument(
XDocument document,
string vsTemplatePath,
object vsExtensionManager = null,
IEnumerable <IRegistryKey> registryKeys = null)
{
// Ignore XML namespaces since VS does not check them either when loading vstemplate files.
IEnumerable <XElement> packagesElements = document.Root.ElementsNoNamespace("WizardData")
.ElementsNoNamespace("packages");
foreach (var packagesElement in packagesElements)
{
IList <PreinstalledPackageInfo> packages = new PreinstalledPackageInfo[0];
string repositoryPath = null;
bool isPreunzipped = false;
string isPreunzippedString = packagesElement.GetOptionalAttributeValue("isPreunzipped");
if (!String.IsNullOrEmpty(isPreunzippedString))
{
Boolean.TryParse(isPreunzippedString, out isPreunzipped);
}
packages = GetPackages(packagesElement).ToList();
if (packages.Count > 0)
{
RepositoryType repositoryType = GetRepositoryType(packagesElement);
repositoryPath = GetRepositoryPath(packagesElement, repositoryType, vsTemplatePath, vsExtensionManager, registryKeys);
}
yield return(new PreinstalledPackageConfiguration(repositoryPath, packages, isPreunzipped));
}
}
public IGoalRepository GetRepository(IDataDomainRequest request, RepositoryType type)
{
try
{
IGoalRepository repo = null;
switch (type)
{
case RepositoryType.PatientGoal:
{
repo = new MongoPatientGoalRepository(request.ContractNumber);
break;
}
case RepositoryType.PatientBarrier:
{
repo = new MongoPatientBarrierRepository(request.ContractNumber);
break;
}
case RepositoryType.PatientTask:
{
repo = new MongoPatientTaskRepository(request.ContractNumber);
break;
}
case RepositoryType.PatientIntervention:
{
repo = new MongoPatientInterventionRepository(request.ContractNumber);
break;
}
case RepositoryType.Goal:
{
repo = new MongoGoalRepository(request.ContractNumber);
break;
}
case RepositoryType.Task:
{
repo = new MongoTaskRepository(request.ContractNumber);
break;
}
case RepositoryType.Intervention:
{
repo = new MongoInterventionRepository(request.ContractNumber);
break;
}
}
repo.UserId = request.UserId;
return(repo);
}
catch (Exception ex)
{
throw ex;
}
}
public static IErrorMessageGenerator CreateGenerator(RepositoryType type)
{
switch (type){
case RepositoryType.Postgres:
return new ErrorMessageGeneratorPostgres();
}
throw new ArgumentException("The repository type is unknown to the message generator");
}
public DbContextOption(IOMode mode, RepositoryType type, string connectionStringName = "", IDbContext context = null, Type dbContextType = null)
{
this.ConnectionStringName = connectionStringName;
this.DbContext = context;
this.IOMode = mode;
this.RepositoryType = type;
this.DbContextType = dbContextType;
}
public static List<Hero> GetHeroes(RepositoryType repositoryType)
{
if(!Repositories.ContainsKey(repositoryType))
throw new ArgumentOutOfRangeException();
var repository = Repositories[repositoryType];
return repository.GetHeroes();
}
IObservable <IEnumerable <RepositoryCacheItem> > GetUserRepositoriesFromApi(RepositoryType repositoryType)
{
return(apiClient.GetUserRepositories(repositoryType)
.WhereNotNull()
.Select(RepositoryCacheItem.Create)
.ToList()
.Catch <IEnumerable <RepositoryCacheItem>, Exception>(_ => Observable.Return(Enumerable.Empty <RepositoryCacheItem>())));
}
public void Assign(Repository source)
{
if (source == null)
return;
Path = source.Path;
Title = source.Title;
Description = source.Description;
RepositoryType = source.RepositoryType;
}
public Task TriggerFetch(string repositoryUrl, RepositoryType repositoryType)
{
var parameters = new[]
{
new KeyValuePair<string, string>("format", "basic"),
new KeyValuePair<string, string>("url", repositoryUrl),
new KeyValuePair<string, string>("scm", repositoryType == RepositoryType.Mercurial ? "hg" : null)
};
return Client.PostAsync("", parameters);
}
public static DropboxInfo CreateV1Info(JObject payload, RepositoryType repositoryType)
{
return new DropboxInfo
{
Deployer = DropboxHelper.Dropbox,
DeployInfo = payload.ToObject<DropboxDeployInfo>(),
RepositoryType = repositoryType,
IsReusable = false,
OAuthVersion = 1
};
}
public static void AddRepository(RepositoryType repositoryType, IHeroRepository repository)
{
var cachingRepository = new CachingRepository(repository);
if (Repositories.ContainsKey(repositoryType))
{
Repositories[repositoryType] = cachingRepository;
}
else
{
Repositories.Add(repositoryType, cachingRepository);
}
}
public void CloneRepository(string source, RepositoryType type)
{
switch (type)
{
case RepositoryType.Git:
new GitExeRepository(_path).Clone(source);
break;
case RepositoryType.Mercurial:
new HgRepository(_path).Clone(source);
break;
}
}
public static RepositoryBase Create(RepositoryType type, string path, string repoName, string project, string userId, string userName, string password, string remoteName)
{
switch (type)
{
case RepositoryType.GitHub:
return new GitHubRepository(path, repoName, userName, password);
case RepositoryType.VisualStudioOnline:
return new VisualStudioOnlineRepository(path, repoName, project, userId, userName, password, remoteName);
default:
throw new InvalidOperationException("Unknown repository type.");
}
}
public static void EnsureRepository(IRepositoryManager repositoryManager,
RepositoryType expectedType)
{
RepositoryType currentType = repositoryManager.GetRepositoryType();
if (currentType == RepositoryType.None) {
repositoryManager.CreateRepository(expectedType);
}
else if (currentType != expectedType) {
throw new InvalidOperationException("Unexpected repository type: " + currentType);
}
}
public void EnsuringGitRepositoryThrowsIfDifferentRepositoryAlreadyExists(RepositoryType repoType, bool isGit, bool isMercurial, string message)
{
// Arrange
var repoFactory = new Mock<RepositoryFactory>(Mock.Of<IEnvironment>(), Mock.Of<IDeploymentSettingsManager>(), Mock.Of<ITraceFactory>()) { CallBase = true };
repoFactory.SetupGet(f => f.IsGitRepository)
.Returns(isGit);
repoFactory.SetupGet(f => f.IsHgRepository)
.Returns(isMercurial);
// Act and Assert
var ex = Assert.Throws<InvalidOperationException>(() => repoFactory.Object.EnsureRepository(repoType));
Assert.Equal(message, ex.Message);
}
private static RepositoryType[] RemoveExceptions(RepositoryType[] repositoryType)
{
if (_exceptions == null || _exceptions.Length == 0)
return repositoryType;
var list = new List<RepositoryType>();
list.AddRange(repositoryType);
foreach (var exception in _exceptions.Where(list.Contains))
{
list.Remove(exception);
}
return list.ToArray();
}
public ActionResult Create(RepositoryType type)
{
try {
_repositoryManager.CreateRepository(type);
return Redirect("~/Hubs/SourceControl/index.htm");
}
catch(Exception e) {
ModelState.AddModelError("_FORM", e.Message);
}
PopulateRepositoyTypes();
return View("Index", RepositoryType.None);
}
/// <summary>
/// Creates the <see cref="IRepository"/> instance to a given <see cref="RepositoryType"/>.
/// </summary>
/// <param name="typeToCreate">The type of <see cref="IRepository"/> to create.</param>
/// <returns>
/// An instance of <see cref="IRepository"/>.
/// </returns>
/// <exception cref="ArgumentException">Is thrown when <paramref name="typeToCreate"/> is not a valid <see cref="RepositoryType"/> value.</exception>
/// <exception cref="NotSupportedException">Is thrown when no <see cref="IRepository"/> instance can be created to the passed <paramref name="typeToCreate"/>.</exception>
public static IRepository CreateRepository(RepositoryType typeToCreate)
{
if (!Enum.IsDefined(typeof(RepositoryType), typeToCreate))
{
throw new ArgumentException("Passed RepositoryType value is not defined in the enumeration.", "typeToCreate");
}
switch (typeToCreate)
{
case RepositoryType.FileRepository:
return new FileRepository();
case RepositoryType.Undefined:
default:
throw new NotSupportedException("Not supported repository type: " + typeToCreate.ToString());
}
}
private void LoadHeroList(RepositoryType repositoryType, string source)
{
StartLongRunningProcess($"Retrieving from {source}...");
var worker = new BackgroundWorker();
worker.DoWork += (obj, args) =>
{
args.Result = HeroFactory.GetHeroes(repositoryType);
};
worker.RunWorkerCompleted += (obj, args) =>
{
var heroes = args.Result as List<Hero>;
ShowResults(heroes, source);
};
worker.RunWorkerAsync();
}
public static IEnumerable<TestCaseData> Build(RepositoryType[] includeType)
{
if (includeType.Contains(RepositoryType.InMemory))
{
yield return new TestCaseData(new InMemoryRepository<User, string, int>()).SetName("InMemoryRepository Test");
}
if (includeType.Contains(RepositoryType.Ef5))
{
var dbPath = EfDataDirectoryFactory.Build();
Database.DefaultConnectionFactory = new SqlCeConnectionFactory("System.Data.SqlServerCe.4.0");
yield return new TestCaseData(new EfRepository<User, string, int>(new TestObjectEntities("Data Source=" + dbPath))).SetName("EfRepository Test");
}
if (includeType.Contains(RepositoryType.Cache))
{
yield return new TestCaseData(new CacheRepository<User, string, int>(CachePrefixFactory.Build())).SetName("CacheRepository Test");
}
}
public void GenericHandlerRepositoryTypeTest(string url, bool? is_hg, RepositoryType expected)
{
// Arrange
var handler = new GenericHandler();
var payload = new JObject();
payload["url"] = url;
payload["format"] = "basic";
if (is_hg != null)
{
payload["scm"] = is_hg.Value ? "hg" : "git";
}
// Act
DeploymentInfo deploymentInfo;
DeployAction result = handler.TryParseDeploymentInfo(request: null, payload: payload, targetBranch: null, deploymentInfo: out deploymentInfo);
// Assert
Assert.Equal(DeployAction.ProcessDeployment, result);
Assert.NotNull(deploymentInfo);
Assert.Equal(expected, deploymentInfo.RepositoryType);
}
public async Task<ActionResult> TriggerFetch(string slug, string repositoryUrl, RepositoryType repositoryType)
{
IApplication application = _applicationService.GetApplication(slug);
if (application == null)
{
return HttpNotFound();
}
ICredentials credentials = _credentialProvider.GetCredentials();
RemoteFetchManager fetchManager = application.GetFetchManager(credentials);
try
{
await fetchManager.TriggerFetch(repositoryUrl, repositoryType);
}
catch (HttpUnsuccessfulRequestException)
{
// Ignore any failures in triggering the deployment
}
return new EmptyResult();
}
public static DropboxInfo CreateV2Info(string dropboxPath, string oauthToken, RepositoryType repositoryType)
{
if (String.IsNullOrEmpty(dropboxPath))
{
throw new ArgumentNullException("dropboxPath");
}
if (String.IsNullOrEmpty(oauthToken))
{
throw new ArgumentNullException("oauthToken");
}
return new DropboxInfo
{
DeployInfo = new DropboxDeployInfo
{
Path = dropboxPath,
Token = oauthToken
},
OAuthVersion = 2,
RepositoryType = repositoryType
};
}
private string GetCloneUrl(IApplication application, RepositoryType type)
{
return application.ServiceUrl + (type == RepositoryType.Git ? "git" : "hg");
}
public void SetupRepo()
{
_repo = new CreditRepositoryType(true);
}
public void SetupRepo()
{
_repo = new AccountRepositoryType(true);
_debitRepo = new DebitRepositoryType(true);
}
void RunSvn(string baseFolder, string baseUrl, RepositoryType repositoryType)
{
if (repositoryType == RepositoryType.SVN)
{
if (baseUrl.EndsWith("/") == false)
baseUrl += "/";
}
if (baseFolder.EndsWith("\\") == false)
baseFolder += "\\";
List<FolderLinkData> urls = new List<FolderLinkData>();
urls.Add(new FolderLinkData(baseUrl, ""));
while (urls.Count > 0)
{
if (_waitingForStop.WaitOne(0, false) == true)
{
WriteToScreen("Stopping...");
lock (_filesToDownload)
{
_filesToDownload.Clear();
}
break;
}
FolderLinkData targetUrlData = urls[0];
string targetUrl = targetUrlData.Url;
urls.RemoveAt(0);
// Create the folder
string relative;
if (targetUrlData.RelativePath == null)
relative = targetUrl.Substring(baseUrl.Length);
else
relative = targetUrlData.RelativePath;
relative = relative.Replace("/", "\\");
string targetFolder = Path.Combine(baseFolder, relative);
if (Directory.Exists(targetFolder) == false)
Directory.CreateDirectory(targetFolder);
// Download target page
string page = null;
bool retry = true;
while (retry == true)
{
if (_waitingForStop.WaitOne(0, false) == true)
return;
try
{
page = DownloadUrl(targetUrl);
retry = false;
}
catch (Exception ex)
{
WriteToScreen("Failed to download: " + ex.Message);
}
}
if (repositoryType == RepositoryType.SVN)
{
List<string> links = ParseLinks(page);
foreach (string link in links)
{
string linkFullUrl = targetUrl + link;
if (linkFullUrl.EndsWith("/") == true)
{
urls.Add(new FolderLinkData(linkFullUrl, null));
}
else // file - download
{
string fileName = targetFolder + link;
lock (_filesToDownload)
{
_filesToDownload.Add(new FileDownloadData(linkFullUrl, fileName));
}
}
}
}
else if (repositoryType == RepositoryType.GIT)
{
List<PageLink> links = ParseGitLinks(page);
int pos = targetUrl.IndexOf("/?");
string serverUrl = targetUrl.Substring(0, pos);
foreach (PageLink link in links)
{
string linkFullUrl = serverUrl + link.Url;
if (link.IsFolder == true)
urls.Add(new FolderLinkData(linkFullUrl, targetUrlData.RelativePath + link.Name + "\\"));
else
{
string fileName = targetFolder + link.Name;
lock (_filesToDownload)
{
_filesToDownload.Add(new FileDownloadData(linkFullUrl, fileName));
}
}
}
}
}
}
public IObservable<Repository> GetUserRepositories(RepositoryType repositoryType)
{
var request = new RepositoryRequest
{
Type = repositoryType,
Direction = SortDirection.Ascending,
Sort = RepositorySort.FullName
};
return gitHubClient.Repository.GetAllForCurrent(request);
}
private string GetRepositoryPath(
XElement packagesElement,
RepositoryType repositoryType,
string vsTemplatePath,
object vsExtensionManager,
IEnumerable<IRegistryKey> registryKeys)
{
switch (repositoryType)
{
case RepositoryType.Template:
return Path.GetDirectoryName(vsTemplatePath);
case RepositoryType.Extension:
return GetExtensionRepositoryPath(packagesElement, vsExtensionManager);
case RepositoryType.Registry:
return GetRegistryRepositoryPath(packagesElement, registryKeys);
}
// should not happen
return null;
}
private string GetCloneUrl(Site site, RepositoryType type)
{
return site.ServiceUrl + (type == RepositoryType.Git ? "git" : "hg");
}
private bool TryGetExistingRepositoryType(out RepositoryType repositoryType)
{
if (IsNullRepository)
{
repositoryType = RepositoryType.None;
return true;
}
else if (IsGitRepository)
{
repositoryType = RepositoryType.Git;
return true;
}
else if (IsHgRepository)
{
repositoryType = RepositoryType.Mercurial;
return true;
}
repositoryType = default(RepositoryType);
return false;
}
