public void NoSaveProjectWithoutUsersTest()
{
MsSqlFactory factory = new MsSqlFactory(Common.Connectionconfig);
IDataBaseProvider provider = factory.CreateDBProvider();
using (var context = ((DataProvider)provider).GenerateContext())
{
ProjectModel projectModel = null;
try
{
projectModel = new ProjectModel(provider)
{
ProjectDetails = new EProject
{
ProjectName = "Test project name 1",
Description = "ProjectDescr"
}
};
Assert.IsFalse(projectModel.SaveProject());
Assert.IsTrue(projectModel.ProjectDetails.Id == 0);
Assert.IsNull(
context.User_Project.FirstOrDefault(
u => u.ID_Project == projectModel.ProjectDetails.Id),
"User_project is saved");
}
finally
{
if (projectModel != null && projectModel.ProjectDetails.Id > 0)
{
provider.DeleteProject(projectModel.ProjectDetails.Id);
}
}
}
}
public OrderDataProcessor(IDataBaseProvider idbprovider)
{
this._OrderDatabase = idbprovider;
string dbpath = ConfigurationManager.AppSettings["Sqlitepath"];
this._ConnString = @"Data Source=" + dbpath + ";Version=3;";
}
public bool LogIn(HttpResponseBase response, AuthenticateModel authParameters)
{
bool isLogged = false;
if (CheckUser(authParameters.Login, authParameters.Password))
{
IDataBaseProvider provider = BaseBindings.DBFactory.CreateDBProvider();
IUserAccessProvider uprovider = BaseBindings.DBFactory.CreateUserAccessProvider();
UserModel user = new UserModel(uprovider);
user.UserDetails = user.GetUserByEmailLogin(authParameters.Login);
if (user != null)
{
string accToken = uprovider.CreateAccessToken(user.UserDetails.Id);
_CookiesManager.SetToCookie(
response,
CookieType.UserAccessToken, accToken);
_CookiesManager.SetToCookie(
response,
CookieType.UserId, user.UserDetails.Id.ToString());
_CookiesManager.SetToCookie(
response,
CookieType.UserName, user.UserDetails.Name ?? user.UserDetails.Login);
isLogged = true;
}
}
else
{
ClearCookies(response);
authParameters.IsTrueUser = false;
authParameters.ErrorOnUserChecking = "User not found";
}
return(isLogged);
}
public InheritensObjectProvider(string connectionString, IDataBaseProvider databaseProvider, MappingOptionsSet mappingOptionSet)
{
_mappingOptionSet = mappingOptionSet;
_databaseProvider = databaseProvider;
_connectionString = connectionString;
InitializeMapping();
}
public ModelBase()
{
_BaseDbProvider = BaseBindings.DBFactory.CreateDBProvider();
_ClientsDbProvider = BaseBindings.DBFactory.CreateClientsProvider();
_EntitlementsDbProvider = BaseBindings.DBFactory.CreateEntitlementsProvider();
_ProjectsDbProvider = BaseBindings.DBFactory.CreateProjectsProvider();
_UserAccessDbProvider = BaseBindings.DBFactory.CreateUserAccessProvider();
}
public RelationalObjectStore(string connectionString, IDataBaseProvider databaseProvider, MappingOptionsSet mappingOptionsSet, bool autoregister)
{
_relationalObjectProvider = new Dictionary <Type, IObjectProvider>();
_connectionString = connectionString;
_autoregisterTypes = autoregister;
_databaseProvider = databaseProvider;
_mappingOptionsSet = mappingOptionsSet;
}
public AuthenticateManager(IDataBaseProvider dataBaseProvider, IOptions <AuthorizeOptions> options)
{
DataBaseProvider = dataBaseProvider;
Options = options.Value;
User = new UserModel();
Encryptor = SHA256.Create();
Handler = new JwtSecurityTokenHandler();
}
public ProjectsModel(IDataBaseProvider provider)
{
if (provider == null)
{
throw new ArgumentNullException(nameof(provider));
}
_BasicProvider = provider;
}
public PairMatrixViewModel(IDataBaseProvider provider)
{
_provider = provider;
InitializeDescription();
_pairMatrix = new List <PairMatrix <double> >();
LabelText = "";
DisplayName = "PairMatrixViewModel";
}
/// <summary>
/// Initializes a new instance of the <see cref="MainWindowViewModel"/> class.
/// </summary>
/// <param name="viewModelList"></param>
/// <param name="dataProvider"></param>
public MainWindowViewModel(List <IPageViewModel> viewModelList, IDataBaseProvider dataProvider)
{
_dataProvider = dataProvider;
PageViewModels = viewModelList;
UpdateDataOnPage();
InitializePredicates();
InitializeCommands();
}
public ResultViewModel(IDataBaseProvider provider, PriorityVectorSearcher priorityVectorSearcher)
{
_provider = provider;
_priorityVectorSearcher = priorityVectorSearcher;
Criterias = new ObservableCollection <Criteria>();
ExcludedCriterias = new ObservableCollection <Criteria>();
IncludedCriterias = new ObservableCollection <Criteria>();
DisplayName = "ResultViewModel";
}
/// <summary>
/// Initializes a new instance of the <see cref="CollectionView{T}"/>
/// </summary>
/// <param name="itemsPerPage">Count of items per page.</param>
/// <param name="sourceCollection">Collection of settings</param>
/// <param name="provider">Db provider</param>
public CollectionView(int itemsPerPage, ICollection <T> sourceCollection, IDataBaseProvider provider)
{
_itemsPerPage = itemsPerPage;
_provider = provider;
CanMoveLast = PageIndex != PagesCount;
SourceCollection = new ObservableCollection <T>(sourceCollection);
SourceCollection.CollectionChanged += OnCollectionChanged;
Filter();
}
public static void AddObjectStore(this IServiceCollection services, IDataBaseProvider databaseProvider, string connectionString, MappingOptionsSet mappingOptionsSet = null)
{
if (mappingOptionsSet == null)
{
mappingOptionsSet = new MappingOptionsSet().AddDefaultRules();
}
RelationalObjectStore relationalObjectStore = new RelationalObjectStore(connectionString, databaseProvider, mappingOptionsSet, true);
ObjectStoreManager.DefaultObjectStore.RegisterObjectProvider(relationalObjectStore);
services.Add(new ServiceDescriptor(typeof(IObjectProvider), relationalObjectStore));
}
public ActionResult Index()
{
CheckUserAuthorization();
ViewBag.Logged = true;
ProjectsModel model = null;
IDataBaseProvider provider = BaseBindings.DBFactory.CreateDBProvider();
model = new ProjectsModel(provider);
model.AvailableProjects = model.GetProjects(0, 10);
//var projects = provider.GetProjects(0, 10);
//model.AvailableProjects = projects.ToList().ForEach(p => p.ToProjectModel());
return(View(model));
return(View());
}
/// <summary>Common method to save a user.</summary>
/// <param name="provider">DB provider.</param>
/// <returns>Stored model of user.</returns>
private static EUser SaveANewUser(IDataBaseProvider provider, IUserAccessProvider userProvider)
{
SignUpModel userData = new SignUpModel()
{
Login = "******",
EMail = "*****@*****.**",
Password = "******"
};
provider.AddUser(userData);
EUser userModel = userProvider
.GetUserByLoginMail("*****@*****.**");
return(userModel);
}
public void SuccessSaveProjectTest()
{
MsSqlFactory factory = new MsSqlFactory(Common.Connectionconfig);
IDataBaseProvider provider = factory.CreateDBProvider();
IUserAccessProvider usProvider = factory.CreateUserAccessProvider();
UserModel userModel = null;
ProjectModel projectModel = null;
try
{
userModel = new UserModel(usProvider)
{
UserDetails = SaveANewUser(provider, usProvider)
};
projectModel = new ProjectModel(provider)
{
ProjectDetails = new EProject
{
ProjectName = "Test project name 1",
Description = "ProjectDescr"
}
};
projectModel.AddUserToProject(userModel.UserDetails.Id, 0);
Assert.IsTrue(projectModel.SaveProject(), "Unable to save project");
Assert.IsTrue(
projectModel.ProjectDetails.Id > 0,
$"Retuen the bad project ID: {projectModel.ProjectDetails.Id}");
var context = ((DataProvider)provider).GenerateContext();
Assert.IsNotNull(
context.User_Project.FirstOrDefault(
u => u.ID_Project == projectModel.ProjectDetails.Id),
"User_project is not saved");
}
finally
{
if (projectModel != null && projectModel.ProjectDetails.Id > 0)
{
provider.DeleteProject(projectModel.ProjectDetails.Id);
}
using (var context = ((DataProvider)provider).GenerateContext())
{
DeleteUserFromDB(context, userModel?.UserDetails?.Login, userModel?.UserDetails?.EMail);
}
}
}
public static IDataBaseProvider GetNewBaseDbProvider()
{
IDataBaseProvider baseProvider = null;
try
{
baseProvider = _DbFactory.CreateDBProvider();
}
catch (InvalidOperationException ex)
{
throw ex;
}
catch (Exception ex)
{
throw new InvalidOperationException(
"Error on creation a db provider.", ex);
}
return(baseProvider);
}
public DataBaseInitializer(string connectionString, IDataBaseProvider databaseProvider, Func<DbCommand> getCommandFunc)
{
_databaseProvider = databaseProvider;
_connectionString = connectionString;
_getCommandFunc = getCommandFunc;
_tableStatments = new List<IStatement>();
_currentTableInfo = null;
_currentTableStatment = null;
_registeredCreateTableParseMethods = new List<Tuple<Func<IStatement, bool>, Func<IStatement, string, string>>>();
_registeredAddFieldParseMethods = new List<Tuple<Func<IField, bool>, Func<IField, string, string>>>();
_registeredAddConstraintParseMethods = new List<Tuple<Func<IField, bool>, Func<IField, string, string>>>();
AddParseFunc(_registeredCreateTableParseMethods, x => true, DefaultParseCreateTableStatement, false);
AddParseFunc(_registeredAddFieldParseMethods, x => true, DefaultParseAddFieldStatement, false);
AddParseFunc(_registeredAddConstraintParseMethods, x => true, DefaultParseAddConstraintStatement, false);
}
public static DataBaseWorkerQueue GetQueue(string connectionStringName, IDataBaseProvider dataBaseProvider)
{
lock (_instances)
{
DataBaseWorkerQueue returnValue;
if (!_instances.ContainsKey(dataBaseProvider))
{
_instances.Add(dataBaseProvider, new DataBaseWorkerQueue[] { returnValue = new DataBaseWorkerQueue(connectionStringName, dataBaseProvider) }.ToDictionary(x => connectionStringName));
}
else if (!_instances[dataBaseProvider].ContainsKey(connectionStringName))
{
_instances[dataBaseProvider].Add(connectionStringName, returnValue = new DataBaseWorkerQueue(connectionStringName, dataBaseProvider));
}
else
{
returnValue = _instances[dataBaseProvider][connectionStringName];
}
return(returnValue);
}
}
/// <summary>Method check user credentials.</summary>
/// <returns>True - if is right user. False - in another case.</returns>
public bool CheckUser()
{
ErrorOnUserChecking = string.Empty;
if (!string.IsNullOrWhiteSpace(Login) &&
!string.IsNullOrWhiteSpace(Password))
{
try
{
IDataBaseProvider provider = BaseBindings.DBFactory.CreateDBProvider();
IsTrueUser = provider.CheckUserCredentials(Login, Password);
if (!IsTrueUser)
{
ErrorOnUserChecking = "Incorrect login or password";
}
}
catch (InvalidOperationException ex)
{
IsTrueUser = false;
ErrorOnUserChecking = ex.Message;
}
}
return(IsTrueUser);
}
public TaskManagingViewModel(IDataBaseProvider provider)
{
_provider = provider;
DisplayName = "TaskManagingViewModel";
}
public ProjectModel(IDataBaseProvider dbProvider, EProject dbProject) :
this(dbProvider)
{
FillModel(dbProject);
}
public void Update(DataBaseWorker dbWorker, IDataBaseProvider databaseProvider)
{
Init(false);
List <IFillAbleObject> dropCommitEntries = new List <IFillAbleObject>(_items.Count);
List <IFillAbleObject> deattach = new List <IFillAbleObject>(_items.Count);
try
{
dbWorker.SaveObjects(_items.Union(_deletedItems).Cast <IFillAbleObject>(),
x =>
{
switch (x.State)
{
case State.Created:
return(databaseProvider.GetInsertCommandBuilder());
case State.Changed:
return(databaseProvider.GetUpdateCommandBuilder());
case State.Deleted:
x.DeleteChildObjects();
x.SaveChildObjects();
return(databaseProvider.GetDeleteCommandBuilder());
case State.Original:
x.SaveChildObjects();
return(null);
default:
return(null);
}
},
(x, reader) =>
{
switch (x.State)
{
case State.Changed:
case State.Created:
if (reader == null)
{
x.Deattach();
}
else
{
x.Fill(reader);
}
break;
default:
break;
}
},
x =>
{
switch (x.State)
{
case State.Changed:
case State.Created:
dropCommitEntries.Add(x);
x.SaveChildObjects();
break;
case State.Deleted:
x.Deattach();
break;
default:
x.SaveChildObjects();
break;
}
});
if (System.Transactions.Transaction.Current == null)
{
foreach (IFillAbleObject obj in dropCommitEntries)
{
obj.Commit(true);
}
}
else
{
#if !NETCOREAPP1_0
string transactionLocalIdentifier = System.Transactions.Transaction.Current.TransactionInformation.LocalIdentifier;
if (_objectsToCommit.ContainsKey(transactionLocalIdentifier))
{
_objectsToCommit[transactionLocalIdentifier] = _objectsToCommit[transactionLocalIdentifier].Union(dropCommitEntries);
}
else
{
_objectsToCommit.Add(transactionLocalIdentifier, dropCommitEntries);
System.Transactions.Transaction.Current.TransactionCompleted +=
(s, e) =>
{
switch (e.Transaction.TransactionInformation.Status)
{
case System.Transactions.TransactionStatus.Aborted:
foreach (IFillAbleObject obj in _objectsToCommit[e.Transaction.TransactionInformation.LocalIdentifier])
{
obj.Rollback();
}
break;
case System.Transactions.TransactionStatus.Committed:
foreach (IFillAbleObject obj in _objectsToCommit[e.Transaction.TransactionInformation.LocalIdentifier])
{
obj.Commit(true);
}
break;
default:
break;
}
_objectsToCommit.Remove(e.Transaction.TransactionInformation.LocalIdentifier);
};
}
#endif
}
}
catch (EntitySaveException)
{
foreach (IFillAbleObject obj in dropCommitEntries)
{
obj.Rollback();
}
throw;
}
}
public CategoryManager(IDataBaseProvider dataBaseProvider, ILoggerFactory logger)
{
_dataBaseProvider = dataBaseProvider;
Logger = logger.CreateLogger("CategoriesManager");
}
public FavoritesRepositoryController(IDataBaseProvider dataBaseProvider)
{
this.dataBaseProvider = dataBaseProvider;
}
public ProductManager(IDataBaseProvider dataBaseProvider, ICategoryManager categoryManager, ILoggerFactory logger)
{
_dataBaseProvider = dataBaseProvider;
_categoryManager = categoryManager;
Logger = logger.CreateLogger("ProductsManager");
}
public BaseRepository(IDataBaseProvider provider)
{
this._dataset = provider.GetDataSet <TEntity>();
}
public ExceptionFilter(IDataBaseProvider dataBaseProvider)
{
this.dataBaseProvider = dataBaseProvider;
}
public RelationalObjectStore(string connectionString, IDataBaseProvider databaseProvider)
: this(connectionString, databaseProvider, new MappingOptionsSet().AddDefaultRules(), false)
{
}
public ProjectModel(IDataBaseProvider dbProvider) :
this()
{
//_DbProvider = dbProvider;
}
