public object Login(LicenseInputModel licenseInputModel)
{
l_repo = new LicenseRepository(licenseInputModel.Product_Key);
string ErrMsg = string.Empty;
if (l_repo.ProductKey != "")
{
if (validateCrdential(licenseInputModel.Login_ID, licenseInputModel.Password, out ErrMsg))
{
if (validateLicense(licenseInputModel, out ErrMsg))
{
l_repo.SaveLogin(licenseInputModel);
response.status_Description = "Successfully Logged In";
response.status_code = "1";
}
else
{
response.status_Description = ErrMsg;
response.status_code = "0";
}
}
else
{
response.status_Description = ErrMsg;
response.status_code = "0";
}
}
else
{
response.status_Description = "Invalid Product Key";
response.status_code = "0";
}
return(Result(response));
}
public List <LicenseModel> GetLicenseClasses()
{
using (var db = DB.GetContext())
{
return(LicenseRepository.GetLicenses(db, true));
}
}
public void Can_CreateLicense_Test()
{
var mockSet = new Mock <DbSet <License> >();
var mockContext = new Mock <LicensingContext>();
mockContext.Setup(m => m.Licenses).Returns(mockSet.Object);
mockContext.Setup(m => m.Set <License>()).Returns(mockSet.Object);
var license = new License()
{
Name = "VCI ALL - Test",
Description = "VCI ALL - Test",
TitleOfHardware = "M-VCI",
LicenseType = LicenseType.Subscription,
Duration = 2,
DateCreated = DateTime.Now,
DateUpdated = DateTime.Now,
Status = Status.Valid,
ProdFamilyId = 6,
SubscriptionId = 2,
VersionId = 10,
ApplicationId = 2,
ProductTypeId = 7
};
var licenseRepo = new LicenseRepository(mockContext.Object);
var result = licenseRepo.Insert(license);
Assert.IsNotNull(result);
mockContext.Verify(m => m.SaveChanges(), Times.Once);
}
public object AddUser(LICENSE_USER lICENSE_USER)
{
l_repo = new LicenseRepository(lICENSE_USER.Product_Key);
string ErrMsg = string.Empty;
if (l_repo.ProductKey != "")
{
if (ValidateUser(lICENSE_USER.LOGIN_ID, out ErrMsg))
{
l_repo.AddUser(lICENSE_USER);
response.status_Description = "Successfully User Created";
response.status_code = "1";
}
else
{
response.status_Description = ErrMsg;
response.status_code = "0";
}
}
else
{
response.status_Description = "Invalid Product Key";
response.status_code = "0";
}
return(Result(response));
}
public object GetAllLggedUser(string Product_Key)
{
string ErrMsg = string.Empty;
l_repo = new LicenseRepository(Product_Key);
if (l_repo.ProductKey != "")
{
var allUser = l_repo.GetAllActiveLoggedUser();
if (allUser != null && allUser.Count > 0)
{
return(allUser.Select(r => new
{
Login_ID = r.LOGIN_ID,
Password = "",
IPAddress = r.IP_ADDRESS,
DeviceType = r.DEVICE_TYPE,
BrowserInfo = r.BROWSER_INFO,
LogginTime = r.LOGINTIME
}));
}
else
{
//response.status_code = "1";
//response.status_Description = "No Records";
return(new JArray());
}
}
else
{
response.status_Description = "Invalid Product Key";
response.status_code = "0";
}
return(Result(response));
}
public async Task Find_ValidParameters_SetsCorrectResourceAndmethod()
{
var sut = new LicenseRepository(_requestFactory);
await sut.Find("key");
_requestFactory.Received().Create("licenses/{key}", Method.Get);
}
public async Task GetAll_ValidParameters_SetsCorrectResourceAndMethod()
{
var sut = new LicenseRepository(_requestFactory);
await sut.GetAll();
_requestFactory.Received().Create("licenses", Method.Get);
}
public List <UtilityModel <uint> > GetLicenseClasses()
{
using (var db = DB.GetContext())
{
return(LicenseRepository.GetLicenses(db, true)
.Select(l => new UtilityModel <uint>(l.LicenseID, l.LicenseName))
.ToList());
}
}
public async Task Find_ProjectIsSet_AddsProjectParameter()
{
const string expected = "project";
var sut = new LicenseRepository(_requestFactory);
await sut.Find("key", expected);
_request.Received().AddParameterIfNotNull("project", expected);
}
public JsonResult Create([DataSourceRequest] DataSourceRequest request, License license)
{
if (license != null && ModelState.IsValid)
{
LicenseRepository.Insert(license);
}
return(Json(new[] { license }.ToDataSourceResult(request, ModelState)));
}
public async Task Find_FullNameIsSet_AddsFullNameParameter()
{
const string expected = "fullName";
var sut = new LicenseRepository(_requestFactory);
await sut.Find("key", fullName : expected);
_request.Received().AddParameterIfNotNull("fullname", expected);
}
public async Task Find_ValidParameters_AddsKeyUrlSegment()
{
const string expected = "key";
var sut = new LicenseRepository(_requestFactory);
await sut.Find(expected);
_request.Received().AddUrlSegment("key", expected);
}
public async Task GetAll_PopularIsSet_AddsPopularParameter()
{
const bool expected = true;
var sut = new LicenseRepository(_requestFactory);
await sut.GetAll(expected);
_request.Received().AddParameterIfNotNull("popular", expected);
}
public JsonResult Update([DataSourceRequest] DataSourceRequest request, License license)
{
if (license != null && ModelState.IsValid)
{
LicenseRepository.Update(license);
}
return(Json(ModelState.ToDataSourceResult()));
}
public ConfigurationModel()
{
_distributorUrl = DistributorConfigurationRepository.Load();
_licenseCount = LicenseRepository.LicenseCount(SpAgent.Product);
TestConnectionCommand = new RelayCommand(TestConnection, HasValidDistributorUrl);
SaveCommand = new RelayCommand(Save, CanSave);
ActivationCommand = new RelayCommand(() => DisplayState.Navigate(new ActivationPage()));
ViewLicensesCommand = new RelayCommand(() => DisplayState.Navigate(new LicenseListPage()));
}
public List <UtilityModel <uint> > GetLicenses()
{
using (var db = DB.GetContext())
{
var lic = LicenseRepository.GetLicenses(db)
.Select(l => new UtilityModel <uint>(l.LicenseID, l.LicenseName))
.ToList();
lic.Insert(0, new UtilityModel <uint>(0, "No license"));
return(lic);
}
}
public void GetAllReservations()
{
// Arrange
var repo = new LicenseRepository();
// Act
var result = repo.GetAllReservations();
// Assert
Assert.Equal(3, result.Count);
}
private static Dictionary <FeatureTypes, FeatureInformation> GetLicensesFromDatabase()
{
var licenseRepository = new LicenseRepository();
var licenseSettings = licenseRepository.GetLicenseInfo();
if (licenseSettings.Count != 1 || string.IsNullOrWhiteSpace(licenseSettings.Single().Value))
{
return(new Dictionary <FeatureTypes, FeatureInformation>());
}
var licenses = DecryptLicenses(licenseSettings.Single().Value);
return(licenses
.Where(f => f.GetFeatureType() != FeatureTypes.None)
.ToDictionary(f => f.GetFeatureType()));
}
public object KeepAlive(LicenseInputModel licenseInputModel)
{
string ErrMsg = string.Empty;
l_repo = new LicenseRepository(licenseInputModel.Product_Key);
if (l_repo.ProductKey != "")
{
l_repo.LogOff(licenseInputModel);
response.status_Description = "Successfuly Session Extended";
response.status_code = "1";
}
else
{
response.status_Description = "Invalid Product Key";
response.status_code = "0";
}
return(Result(response));
}
public object SessionExpire(string Product_Key)
{
string ErrMsg = string.Empty;
int NoOfUsersExpired;
l_repo = new LicenseRepository(Product_Key);
if (l_repo.ProductKey != "")
{
l_repo.SessionExpire(out NoOfUsersExpired);
response.status_Description = "Successfuly session expired users(" + NoOfUsersExpired.ToString() + ") are killed";
response.status_code = "1";
}
else
{
response.status_Description = "Invalid Product Key";
response.status_code = "0";
}
return(Result(response));
}
/// <summary> Creates a new <see cref="GitLabClient" /> instance. </summary>
/// <param name="hostUri"> The GitLab server to connect to. </param>
/// <param name="privateToken"> The private token to use when making requests to the GitLab API. </param>
public GitLabClient(Uri hostUri, string privateToken = null)
{
if (hostUri == null)
{
throw new ArgumentNullException(nameof(hostUri));
}
var baseUri = new Uri(hostUri, ApiPath);
_authenticator = new PrivateTokenAuthenticator(privateToken);
var clientFactory = new ClientFactory(baseUri, _authenticator);
var requestFactory = new RequestFactory(clientFactory);
Branches = new BranchRepository(requestFactory);
Builds = new BuildRepository(requestFactory);
BuildTriggers = new BuildTriggerRepository(requestFactory);
BuildVariables = new BuildVariableRepository(requestFactory);
Commits = new CommitRepository(requestFactory);
DeployKeys = new DeployKeyRepository(requestFactory);
Emails = new EmailRepository(requestFactory);
Files = new FileRepository(requestFactory);
GitLabLicense = new GitLabLicenseRepository(requestFactory);
GitLabSettings = new GitLabSettingsRepository(requestFactory);
Issues = new IssueRepository(requestFactory);
Keys = new KeyRepository(requestFactory);
Labels = new LabelRepository(requestFactory);
Licenses = new LicenseRepository(requestFactory);
MergeRequests = new MergeRequestRepository(requestFactory);
Milestones = new MilestoneRepository(requestFactory);
Namespaces = new NamespaceRepository(requestFactory);
ProjectSnippets = new ProjectSnippetRepository(requestFactory);
Repositories = new RepositoryRepository(requestFactory);
Runners = new RunnerRepository(requestFactory);
Session = new SessionRepository(requestFactory);
SystemHooks = new SystemHookRepository(requestFactory);
Tags = new TagRepository(requestFactory);
Users = new UserRepository(requestFactory);
Projects = new ProjectRepository(requestFactory);
ProjectMembers = new ProjectMemberRepository(requestFactory);
GroupMembers = new GroupMemberRepository(requestFactory);
}
public void CreateReservation()
{
// Arrange
var repo = new LicenseRepository();
var reservation = new Licenses()
{
Id = Guid.NewGuid(),
Name = "Test",
Description = "TestDescription",
Category = "TestCategory",
Quantity = 1
};
// Act
repo.CreateLicenses(reservation);
var result = repo.GetAllReservations();
// Assert
Assert.Equal(4, result.Count);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
var bus = Bus.Factory.CreateUsingRabbitMq(sbc =>
{
var host = sbc.Host(new Uri("amqp://*****:*****@dove.rmq.cloudamqp.com/msmcpkzk"), h =>
{
h.Username("msmcpkzk");
h.Password("nlP6hJVvCr3mgyr8EI-XU1or5QatPXGe");
});
});
bus.Start();
var repository = new LicenseRepository();
var service = new LicenseService(bus, repository);
services.AddSingleton <ILicensesRepository>(repository);
services.AddSingleton <ILicenseService>(service);
services.AddControllersWithViews();
}
public object GetAllUser(string Product_Key)
{
string ErrMsg = string.Empty;
l_repo = new LicenseRepository(Product_Key);
if (l_repo.ProductKey != "")
{
var allUser = l_repo.GetAllUser();
if (allUser != null && allUser.Count > 0)
{
return(allUser);
}
else
{
return(new JArray());
}
}
else
{
response.status_Description = "Invalid Product Key";
response.status_code = "0";
}
return(Result(response));
}
public void Can_GetLicensesByProductTypeId_Test()
{
var data = new List <License>
{
new License {
Name = "CDR V3.6 2years",
Description = "CDR V3.6 Test",
TitleOfHardware = "CDR Vehicle",
LicenseType = LicenseType.Subscription,
Duration = 2,
DateCreated = DateTime.Now,
DateUpdated = DateTime.Now,
Status = Status.Valid,
ProdFamilyId = 6,
SubscriptionId = 2,
VersionId = 10,
ApplicationId = 2,
ProductTypeId = 7
},
new License {
Name = "BVMS V5.0 1 years",
Description = "BVMS V5.0 1Test",
TitleOfHardware = "BVMS",
LicenseType = LicenseType.Subscription,
Duration = 1,
DateCreated = DateTime.Now,
DateUpdated = DateTime.Now,
Status = Status.Valid,
ProdFamilyId = 6,
SubscriptionId = 2,
VersionId = 10,
ApplicationId = 2,
ProductTypeId = 5
},
new License {
Name = "CDR V4.4.1 1years",
Description = "CDR V4.4.1 1Test",
TitleOfHardware = "CDR Vehicle",
LicenseType = LicenseType.Subscription,
Duration = 1,
DateCreated = DateTime.Now,
DateUpdated = DateTime.Now,
Status = Status.Valid,
ProdFamilyId = 6,
SubscriptionId = 2,
VersionId = 10,
ApplicationId = 2,
ProductTypeId = 7
},
}.AsQueryable();
var mockSet = new Mock <DbSet <License> >();
mockSet.As <IQueryable <License> >().Setup(m => m.Provider).Returns(data.Provider);
mockSet.As <IQueryable <License> >().Setup(m => m.Expression).Returns(data.Expression);
mockSet.As <IQueryable <License> >().Setup(m => m.ElementType).Returns(data.ElementType);
mockSet.As <IQueryable <License> >().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
var mockContext = new Mock <LicensingContext>();
mockContext.Setup(c => c.Licenses).Returns(mockSet.Object);
mockContext.Setup(m => m.Set <License>()).Returns(mockSet.Object);
var licenseRepo = new LicenseRepository(mockContext.Object);
var result = licenseRepo.GetLicensesByProductTypeId(7);
Assert.AreEqual(2, result.Count());
}
public LicenseService(IUnitOfWork unitOfWork, IMapper mapper, LicenseRepository licenseRepository)
{
this.unitOfWork = unitOfWork;
this.mapper = mapper;
this.licenseRepository = licenseRepository;
}
public LicenseReposTest()
{
repos = new LicenseRepository();
}
public LicenseService()
{
_licenseRepository = new LicenseRepository();
_sortingService = new SortingService();
_paginationService = new PaginationService();
}
public JsonResult Read([DataSourceRequest] DataSourceRequest request)
{
return(Json(LicenseRepository.GetAll().ToDataSourceResult(request)));
}
public async Task Find_KeyIsNull_ThrowsArgumentNullException()
{
var sut = new LicenseRepository(_requestFactory);
await Assert.ThrowsAsync <ArgumentNullException>(() => sut.Find(null));
}
