public ProjectController(IUserRepository userRepository, IProjectRepository projectRepository, OrganizationRepository organizationRepository, BillingManager billingManager, NotificationSender notificationSender) {
_userRepository = userRepository;
_projectRepository = projectRepository;
_organizationRepository = organizationRepository;
_billingManager = billingManager;
_notificationSender = notificationSender;
}
public RemoveStaleAccountsJob(OrganizationRepository organizationRepository,
IProjectRepository projectRepository,
IUserRepository userRepository,
IEventRepository eventRepository,
IStackRepository stackRepository)
{
_organizationRepository = organizationRepository;
_projectRepository = projectRepository;
_userRepository = userRepository;
_eventRepository = eventRepository;
_stackRepository = stackRepository;
}
public ManageBillController(UsersAccessRepository usersAccessRepository,
ProjectRepository projectRepository,
UserOrganizationRepository userOrganizationRepository,
SubProjectRepository subProjectRepository,
OrganizationRepository organizationRepository,
BillRepository billRepository) : base(usersAccessRepository)
{
_projectRepository = projectRepository;
_userOrganizationRepository = userOrganizationRepository;
_subProjectRepository = subProjectRepository;
_organizationRepository = organizationRepository;
_billRepository = billRepository;
}
private void LoadFranchisee()
{
IOrganizationRepository franchiseeRepository = new OrganizationRepository();
var franchisees =
franchiseeRepository.GetOrganizationCollection(OrganizationType.Franchisee).OrderBy(fr => fr.Name).ToList();
var namesAndIds = franchisees.Select(f => new { f.Name, f.Id });
ddlSalesPerson.DataSource = namesAndIds;
ddlSalesPerson.DataTextField = "Name";
ddlSalesPerson.DataValueField = "Id";
ddlSalesPerson.DataBind();
ddlSalesPerson.Items.Insert(0, new ListItem("Select Franchisee", "0"));
ddlSalesPerson.SelectedValue = "0";
}
public void SetUp()
{
_context = new ApplicationDbContext();
_context.Database.Delete();
//_context.Database.CreateIfNotExists();
var migrator = new DbMigrator(new Infrastructure.DayCareManagement.Migrations.Configuration());
migrator.Update();
//Database.SetInitializer(new MigrateDatabaseToLatestVersion<ApplicationDbContext,
// Infrastructure.DayCareManagement.Migrations.Configuration>());
_repository = new OrganizationRepository(_context);
}
public ActionResult Delete(int id)
{
var model = new DeleteModel();
var organization = OrganizationRepository.OrganizationFetch(id);
model.Title = "Organization Delete";
model.Id = organization.OrganizationId;
model.Name = "Organization";
model.Description = organization.Name;
model.ControllerName = "Organization";
model.BackUrl = Url.Action("Index", "Home");
return(this.View(model));
}
public DashboardController(NoteRepository noteRepo, AuditAddRepository auditAddRepo, UserRepository userRepo, OrganizationRepository orgRepo, ProjectRepository projectRepo, IAuthenticationService auth)
{
NoteRepo = noteRepo;
OrganizationRepo = orgRepo;
ProjectRepo = projectRepo;
AuditAddRepo = auditAddRepo;
UserRepo = userRepo;
Auth = auth;
}
public static NormaOrganizationSimple rebuildNormaOrganizationSimple(NormaOrganizationSimple inNormaOrganization)
{
NormaOrganizationSimple normaOrganization = new NormaOrganizationSimple(inNormaOrganization.Id);
OrganizationRepository organizationRepository = new OrganizationRepository();
normaOrganization.Norma = rebuildNorma(inNormaOrganization.Norma);
normaOrganization.OrganizationId = inNormaOrganization.OrganizationId;
Organization organization = organizationRepository.Get(inNormaOrganization.OrganizationId);
normaOrganization.OrganizationFullName = organization.FullName;
normaOrganization.Sort = organization.Short;
normaOrganization.IsActive = inNormaOrganization.IsActive;
return(normaOrganization);
}
public StaleAccountsJob(OrganizationRepository organizationRepository,
IProjectRepository projectRepository,
IUserRepository userRepository,
IEventRepository eventRepository,
IStackRepository stackRepository,
ILockProvider lockProvider)
{
_organizationRepository = organizationRepository;
_projectRepository = projectRepository;
_userRepository = userRepository;
_eventRepository = eventRepository;
_stackRepository = stackRepository;
_lockProvider = lockProvider;
}
public async Task <Organization> AddOrganizationAsync(string username, string emailAddress, User adminUser)
{
var existingUserWithIdentity = EntitiesContext.Users
.FirstOrDefault(u => u.Username == username || u.EmailAddress == emailAddress);
if (existingUserWithIdentity != null)
{
if (existingUserWithIdentity.Username.Equals(username, StringComparison.OrdinalIgnoreCase))
{
throw new EntityException(Strings.UsernameNotAvailable, username);
}
if (string.Equals(existingUserWithIdentity.EmailAddress, emailAddress, StringComparison.OrdinalIgnoreCase))
{
throw new EntityException(Strings.EmailAddressBeingUsed, emailAddress);
}
}
var organization = new Organization(username)
{
EmailAllowed = true,
UnconfirmedEmailAddress = emailAddress,
EmailConfirmationToken = Crypto.GenerateToken(),
NotifyPackagePushed = true,
CreatedUtc = DateTimeProvider.UtcNow,
Members = new List <Membership>()
};
if (!Config.ConfirmEmailAddresses)
{
organization.ConfirmEmailAddress();
}
var membership = new Membership {
Organization = organization, Member = adminUser, IsAdmin = true
};
organization.Members.Add(membership);
adminUser.Organizations.Add(membership);
OrganizationRepository.InsertOnCommit(organization);
await SubscribeOrganizationToTenantPolicyIfTenantIdIsSupported(organization, adminUser, commitChanges : false);
await Auditing.SaveAuditRecordAsync(new UserAuditRecord(organization, AuditedUserAction.AddOrganization, membership));
await EntitiesContext.SaveChangesAsync();
return(organization);
}
/// <summary>
/// 删除组织机构信息信息
/// </summary>
/// <param name="ids">要删除的组织机构信息编号</param>
/// <returns>业务操作结果</returns>
public OperationResult DeleteOrganizations(params int[] ids)
{
ids.CheckNotNull("ids");
OperationResult result = OrganizationRepository.Delete(ids,
entity =>
{
if (entity.Children.Any())
{
throw new Exception("组织机构“{0}”的子级不为空，不能删除。".FormatWith(entity.Name));
}
});
return(result);
}
public void FindAthleteByName_When_name_Then_athlete_with_name(string firstName, string lastName, int expected)
{
// Insert seed data into the database using one instance of the context
InitializeAthletes();
InsertAthletes();
var repository = new OrganizationRepository(_context);
var actual = repository.FindAthleteByName(firstName, lastName);
Assert.Equal(firstName, actual.Result.FirstName);
Assert.Equal(lastName, actual.Result.LastName);
Assert.Equal(expected, actual.Result.Id);
}
public void Get_organization_via_async()
{
var repo = new OrganizationRepository();
const string orgName = "Fred's Bar and Grill";
var id = GetOrgIdCreatingIfNeededViaAsync(repo, orgName);
var organizationResult = repo.Get(id);
Assert.IsNotNull(organizationResult);
Assert.IsTrue(organizationResult.IsSuccessful);
var organization = organizationResult.Data;
Assert.AreEqual(orgName, organization.Name);
Assert.AreEqual(0, organization.Terms.Count);
}
public async Task <IActionResult> UpdateImageAsync(string organizationId, Base64Image dataObject)
{
User user = await Session.GetCurrentUser();
if (user == null || string.IsNullOrEmpty(dataObject.Image))
{
return(Unauthorized());
}
byte[] bytes = Convert.FromBase64String(dataObject.Image);
System.IO.MemoryStream ms = new System.IO.MemoryStream(bytes);
return(Ok(await OrganizationRepository.UpdateImageAsync(user, organizationId, ms)));
}
public SignDocumetController(CriteriaRepository <Worker> workerRepository,
CriteriaRepository <SignDocumet> signDocumetRepository,
OrganizationRepository organizationRepository,
CriteriaRepository <StorageName> storageNameRepository,
CriteriaRepository <SignDocTypes> signDocTypesRepository,
CriteriaRepository <SignTypes> signTypesRepository)
{
Check.Require(signDocumetRepository != null, "subscriptionRepository may not be null");
this.workerRepository = workerRepository;
this.signDocumetRepository = signDocumetRepository;
this.organizationRepository = organizationRepository;
this.storageNameRepository = storageNameRepository;
this.signDocTypesRepository = signDocTypesRepository;
this.signTypesRepository = signTypesRepository;
}
public UsersServiceTest()
{
IUnitOfWork uow = new NHUnitOfWork();
IUsersRepository _usersRepository = new UsersRepository(uow);
IRoleRepository _roleRepository = new RoleRepository(uow);
IOrganizationRepository _organizationRepository = new OrganizationRepository(uow);
IOrganizationService _organizationService = new OrganizationService(_organizationRepository, uow);
this._usersIdGenerator = new IdGenerator <Users>();
this._userService = new UsersService(_usersRepository, _organizationService, null, this._usersIdGenerator, uow);
this._organizationService = new OrganizationService(_organizationRepository, uow);
AutoMapperBootStrapper.ConfigureAutoMapper();
}
public void AddRelationTest()
{
var organizationFacilityRepository = new OrganizationFacilityRepository(context);
var organizationFacility = new OrganizationFacility();
var organizationId = new OrganizationRepository(context).GetAll().OrderByDescending(x => x.Id).FirstOrDefault().Id;
var facilityId = new FacilityRepository(context).GetAll().OrderByDescending(x => x.Id).FirstOrDefault().Id;
var relation = true;
var createdBy = "1234";
var result = organizationFacilityRepository.AddRelationAsync(organizationId, facilityId, relation, createdBy).Result;
Assert.AreEqual(true, result);
}
public ActionResult CreateTenantWithSocialProvider(string OrganizationName, HttpPostedFileBase logoFile)
{
string organizationInternalName = SanitizeString(OrganizationName);
if (this.IsOrganizationNameValid(organizationInternalName))
{
var ipName = ClaimHelper.GetCurrentUserClaim(Fabrikam.ClaimTypes.IdentityProvider).Value;
if (ipName == SocialIdentityProviders.WindowsLiveId.HomeRealm)
{
ipName = SocialIdentityProviders.WindowsLiveId.DisplayName;
}
Organization organization = new Organization {
Name = organizationInternalName, DisplayName = OrganizationName, HomeRealm = ipName, LogoPath = "~/Content/images/generic-logo.png"
};
if (logoFile != null && logoFile.ContentLength > 0)
{
var imageFolderRelativePath = "~/Content/images/";
var imageFolderAbsolutePath = Server.MapPath("~/");
imageFolderAbsolutePath = string.Concat(imageFolderAbsolutePath, "..\\f-shipping.7\\Content\\images\\");
var fileName = string.Concat(organizationInternalName, "-logo.png");
var fileFullPath = string.Concat(imageFolderAbsolutePath, fileName);
logoFile.SaveAs(fileFullPath);
organization.LogoPath = string.Concat(imageFolderRelativePath, fileName);
}
OrganizationRepository organizationRepository = new OrganizationRepository();
organizationRepository.AddOrganization(organization);
ServiceManagementWrapper acsWrapper = new ServiceManagementWrapper(acsServiceNamespace, acsUsername, acsPassword);
var relayingPartyName = organizationInternalName;
var realmAddress = string.Format("https://localhost/f-shipping.7/{0}", organizationInternalName);
var replyAddress = string.Format("https://localhost/f-shipping.7/{0}/FederationResult", organizationInternalName);
var ruleGroup = string.Format("Default role group for {0}", organizationInternalName);
var socialProviders = new string[] { ipName };
acsWrapper.AddRelyingParty(organizationInternalName, realmAddress, replyAddress, null, null, null, ruleGroup, socialProviders);
var nameIdentifierValue = ClaimHelper.GetCurrentUserClaim(ClaimTypes.NameIdentifier).Value;
CreateRulesForTenantWithSocialIP(organizationInternalName, ipName, acsWrapper, ruleGroup, nameIdentifierValue);
return(View("CompleteEnrollment"));
}
return(View("EnrollWithSocialProvider", new EnrollmentViewModel {
ErrorMessage = "Organization name not valid", OrganizationName = OrganizationName
}));
}
public async Task <Organization> Update(Organization organization)
{
if (!ValidateOrganization(organization))
{
throw new ArgumentException("Invalid Organization!");
}
if (organization.Id == Guid.Empty)
{
throw new ArgumentException("Organization has no id!");
}
//merge organization
Organization existing = await GetById(organization.Id);
if (existing == null)
{
return(null);
}
if (!string.IsNullOrWhiteSpace(organization.Name))
{
existing.Name = organization.Name;
}
if (!string.IsNullOrWhiteSpace(organization.Description))
{
existing.Description = organization.Description;
}
if (organization.Data != null)
{
foreach (var kv in organization.Data)
{
if (existing.Data.ContainsKey(kv.Key))
{
existing.Data[kv.Key] = kv.Value;
}
else
{
existing.Data.Add(kv.Key, kv.Value);
}
}
}
return(await OrganizationRepository.Update(existing));
}
public bool IsValid(int id, Project project)
{
CurrentUserOrgIds = CurrentUser.OrganizationIds.OrEmpty();
var original = ProjectRepository.Get()
.Where(p => p.Id == id)
.Include(p => p.Organization)
.Include(p => p.Owner)
.ThenInclude(u => u.OrganizationMemberships)
.ThenInclude(om => om.Organization)
.Include(p => p.Group)
.ThenInclude(g => g.Owner)
.FirstOrDefaultAsync().Result;
ValidateOrganizationHeader(original.OrganizationId, "project");
if ((project.OrganizationId != VALUE_NOT_SET) ||
(project.OwnerId != VALUE_NOT_SET) ||
(project.GroupId != VALUE_NOT_SET))
{
ProjectOwner = original.Owner;
Organization = original.Organization;
Group = original.Group;
// Set the fields to what would be the updated versions
// Fields that don't change, get their value from the original
if (project.OrganizationId != VALUE_NOT_SET)
{
Organization = OrganizationRepository.Get()
.Where(o => o.Id == project.OrganizationId)
.FirstOrDefaultAsync().Result;
}
if (project.GroupId != VALUE_NOT_SET)
{
Group = GroupRepository.Get()
.Where(g => g.Id == project.GroupId)
.Include(g => g.Owner).FirstOrDefaultAsync().Result;
}
if (project.OwnerId != VALUE_NOT_SET)
{
ProjectOwner = UserRepository.Get()
.Where(u => u.Id == project.OwnerId)
.Include(u => u.OrganizationMemberships)
.ThenInclude(om => om.Organization)
.FirstOrDefaultAsync().Result;
}
base.ValidateProject();
}
return(base.IsValid());
}
private bool IsOrganizationNameValid(string organizationName)
{
if (string.IsNullOrEmpty(organizationName))
{
return(false);
}
if (organizationName.Length < 2)
{
return(false);
}
OrganizationRepository organizationRepository = new OrganizationRepository();
return(organizationRepository.IsNameAvailable(organizationName));
}
public void SetUp()
{
_mpServiceMock = new Mock <IMinistryPlatformService>();
_authService = new Mock <IAuthenticationRepository>();
_configWrapper = new Mock <IConfigurationWrapper>();
_configWrapper.Setup(m => m.GetEnvironmentVarAsString("API_USER")).Returns("uid");
_configWrapper.Setup(m => m.GetEnvironmentVarAsString("API_PASSWORD")).Returns("pwd");
_configWrapper.Setup(m => m.GetConfigIntValue("OrganizationsPage")).Returns(OrgPage);
_configWrapper.Setup(m => m.GetConfigIntValue("LocationsForOrg")).Returns(LocPage);
_authService.Setup(m => m.Authenticate(It.IsAny <string>(), It.IsAny <string>())).Returns(new Dictionary <string, object> {
{ "token", "ABC" }, { "exp", "123" }
});
_fixture = new OrganizationRepository(_authService.Object, _configWrapper.Object, _mpServiceMock.Object);
}
public AuthController(
TokenProvider tokenProvider, SaltedHash saltedHash, ISessionContext sessionContext,
UserRepository userRepository, MemberRepository memberRepository,
OrganizationRepository organizationRepository, GroupRepository groupRepository, BranchContext branchContext,
IOptions <EnviromentAccessOptions> options)
{
_tokenProvider = tokenProvider;
_saltedHash = saltedHash;
_sessionContext = sessionContext;
_userRepository = userRepository;
_memberRepository = memberRepository;
_organizationRepository = organizationRepository;
_groupRepository = groupRepository;
_branchContext = branchContext;
_options = options.Value;
}
public HttpResponseMessage GetAll(HttpRequestMessage request)
{
try
{
List <Organization> organizations;
using (OrganizationRepository repository = new OrganizationRepository())
{
organizations = repository.GetAll().ToList();
}
return(request.CreateResponse <List <Organization> >(HttpStatusCode.OK, organizations));
}
catch (Exception e)
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, "Não foi possível listar as organizações [" + e.Message + "]"));
}
}
public HttpResponseMessage Add(HttpRequestMessage request, Organization org)
{
try
{
using (OrganizationRepository repository = new OrganizationRepository())
{
repository.Add(org);
repository.SaveAll();
}
return(request.CreateResponse <Organization>(HttpStatusCode.OK, org));
}
catch (Exception e)
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, "Não foi possível inserir usuário [" + e.Message + "]"));
}
}
public HttpResponseMessage Update(HttpRequestMessage request, Organization org)
{
try
{
using (OrganizationRepository repository = new OrganizationRepository())
{
repository.Update(org);
repository.SaveAll();
}
return(request.CreateResponse <Organization>(HttpStatusCode.OK, org));
}
catch (Exception e)
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, e.Message));
}
}
public async Task DoesNotCreateDuplicateReports()
{
int organizationId;
using (var context = new TestHedwigContextProvider().Context)
{
var organization = OrganizationHelper.CreateOrganization(context);
organizationId = organization.Id;
var fundingSpace = FundingSpaceHelper.CreateFundingSpace(context, organizationId);
organization.FundingSpaces = new List <FundingSpace> {
fundingSpace
};
var currentReportingPeriod = ReportingPeriodHelper.CreateReportingPeriod(context);
}
using (var context = new TestHedwigContextProvider().Context)
{
var logger = new Mock <ILogger <CdcReportGeneratorScopedService> >();
var orgRepo = new OrganizationRepository(context);
var reportingPeriodRepo = new ReportingPeriodRepository(context);
var reportRepo = new ReportRepository(context);
var dateTime = new Mock <IDateTime>();
dateTime.Setup(dateTime => dateTime.UtcNow).Returns(DateTime.Parse("2019-10-01"));
var cdcReportGenerator = new CdcReportGeneratorScopedService(
logger.Object,
orgRepo,
reportingPeriodRepo,
reportRepo,
dateTime.Object
);
var previousReports = reportRepo.GetReportsForOrganization(organizationId);
await cdcReportGenerator.TryGenerateReports();
await cdcReportGenerator.TryGenerateReports();
await cdcReportGenerator.TryGenerateReports();
var reports = reportRepo.GetReportsForOrganization(organizationId);
Assert.Empty(previousReports);
Assert.Single(reports);
}
}
private async Task ShowExistingOrganizations()
{
if (!this.IsControlsEnabled)
{
return;
}
ConnectionData connectionData = GetSelectedConnection();
ToggleControls(connectionData, false, Properties.OutputStrings.LoadingOrganizations);
this.Dispatcher.Invoke(() =>
{
this._itemsSource.Clear();
});
IEnumerable <Organization> list = Enumerable.Empty <Organization>();
try
{
var service = await GetService();
if (service != null)
{
var repository = new OrganizationRepository(service);
list = await repository.GetListAsync();
}
}
catch (Exception ex)
{
this._iWriteToOutput.WriteErrorToOutput(connectionData, ex);
}
string textName = string.Empty;
txtBFilter.Dispatcher.Invoke(() =>
{
textName = txtBFilter.Text.Trim().ToLower();
});
list = FilterList(list, textName);
LoadSavedOrganizations(list);
ToggleControls(connectionData, true, Properties.OutputStrings.LoadingOrganizationsCompletedFormat1, list.Count());
}
public override IController CreateController(RequestContext requestContext, string controllerName)
{
if (db == null)
{
db = new MyOrganizationEntities();
}
if (userRep == null)
{
userRep = new UserRepository(db);
}
if (repImage == null)
{
repImage = new ImageRepository(db);
}
if (repOrg == null)
{
repOrg = new OrganizationRepository(db);
}
if (repOrgUser == null)
{
repOrgUser = new OrgUserRepository(db);
}
if (repOrgImage == null)
{
repOrgImage = new OrgImageRepository(db);
}
if (repComment == null)
{
repComment = new CommentRepository(db);
}
if (controllerName == "Home")
{
IController cnt1 = new HomeController(userRep);
return(cnt1);
}
if (controllerName == "OrganizationFinal")
{
IController cnt1 = new OrganizationFinalController(userRep, repImage, repOrg, repOrgUser, repOrgImage, repComment);
return(cnt1);
}
return(base.CreateController(requestContext, controllerName));
}
public MatPersonController(
CriteriaRepository <MatPersonCardHead> matPersonCardHeadRepository,
CriteriaRepository <Worker> workerRepository,
StorageNameRepository storageNameRepository,
OrganizationRepository organizationRepository,
CriteriaRepository <WorkerWorkplace> workerWorkplaceRepository,
CriteriaRepository <MatPersonCardContent> matPersonCardContentRepository
)
{
Check.Require(matPersonCardHeadRepository != null, "matPersonCardHeadRepository may not be null");
this.matPersonCardHeadRepository = matPersonCardHeadRepository;
this.workerRepository = workerRepository;
this.organizationRepository = organizationRepository;
this.workerWorkplaceRepository = workerWorkplaceRepository;
this.storageNameRepository = storageNameRepository;
this.matPersonCardContentRepository = matPersonCardContentRepository;
}
public void Propagates_Same_Context()
{
var mockContext = new Mock <CountryContext>();
var service = new TestUnitofWork(mockContext.Object);
// Act
CountryRepository countryRep = service.CountryRepository as CountryRepository;
CurrencyRepository currencyRep = service.CurrencyRepository as CurrencyRepository;
OrganizationRepository orgRep = service.OrganizationRepository as OrganizationRepository;
Assert.IsNotNull(countryRep);
Assert.IsNotNull(currencyRep);
Assert.IsNotNull(orgRep);
Assert.AreSame(countryRep.Context, currencyRep.Context);
Assert.AreSame(countryRep.Context, orgRep.Context);
}
public HttpResponseMessage Delete(HttpRequestMessage request, int id)
{
try
{
using (OrganizationRepository rep = new OrganizationRepository())
{
Func <Organization, bool> delete = (o => o.ID == id);
rep.Delete(delete);
rep.SaveAll();
}
return(request.CreateResponse(HttpStatusCode.Accepted));
}
catch (Exception e)
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, e.Message));
}
}
public TestRegisterController(CriteriaRepository <TestRegister> testRegisterRepository,
CriteriaRepository <TestRegisterSimple> testRegisterSimpleRepository,
OrganizationRepository organizationRepository,
CriteriaRepository <Result> resultRepository,
CriteriaRepository <Provaider> provaiderRepository,
CriteriaRepository <Certificate> certificateRepository,
CriteriaRepository <NomGroup> nomGroupRepository)
{
Check.Require(testRegisterRepository != null, "testRegisterRepository may not be null");
this.testRegisterRepository = testRegisterRepository;
this.testRegisterSimpleRepository = testRegisterSimpleRepository;
this.organizationRepository = organizationRepository;
this.resultRepository = resultRepository;
this.provaiderRepository = provaiderRepository;
this.certificateRepository = certificateRepository;
this.nomGroupRepository = nomGroupRepository;
}
public RemoveStaleAccountsJob(OrganizationRepository organizationRepository,
IProjectRepository projectRepository,
IUserRepository userRepository,
IErrorRepository errorRepository,
IErrorStackRepository errorStackRepository,
DayStackStatsRepository dayStackStats,
MonthStackStatsRepository monthStackStats,
DayProjectStatsRepository dayProjectStats,
MonthProjectStatsRepository monthProjectStats) {
_organizationRepository = organizationRepository;
_projectRepository = projectRepository;
_userRepository = userRepository;
_errorRepository = errorRepository;
_errorStackRepository = errorStackRepository;
_dayStackStats = dayStackStats;
_monthStackStats = monthStackStats;
_dayProjectStats = dayProjectStats;
_monthProjectStats = monthProjectStats;
}
public RemoveStaleAccountsJob(OrganizationRepository organizationRepository,
IProjectRepository projectRepository,
IUserRepository userRepository,
IEventRepository eventRepository,
IStackRepository stackRepository,
IDayStackStatsRepository dayStackStats,
IMonthStackStatsRepository monthStackStats,
IDayProjectStatsRepository dayProjectStats,
IMonthProjectStatsRepository monthProjectStats)
{
_organizationRepository = organizationRepository;
_projectRepository = projectRepository;
_userRepository = userRepository;
_eventRepository = eventRepository;
_stackRepository = stackRepository;
_dayStackStats = dayStackStats;
_monthStackStats = monthStackStats;
_dayProjectStats = dayProjectStats;
_monthProjectStats = monthProjectStats;
}
public DataHelper(OrganizationRepository organizationRepository,
ProjectRepository projectRepository,
UserRepository userRepository,
ErrorRepository errorRepository,
ErrorStackRepository errorStackRepository,
DayStackStatsRepository dayStackStats,
MonthStackStatsRepository monthStackStats,
DayProjectStatsRepository dayProjectStats,
MonthProjectStatsRepository monthProjectStats,
ErrorStatsHelper errorStatsHelper,
BillingManager billingManager) {
_organizationRepository = organizationRepository;
_projectRepository = projectRepository;
_userRepository = userRepository;
_errorRepository = errorRepository;
_errorStackRepository = errorStackRepository;
_dayStackStats = dayStackStats;
_monthStackStats = monthStackStats;
_dayProjectStats = dayProjectStats;
_monthProjectStats = monthProjectStats;
_statsHelper = errorStatsHelper;
_billingManager = billingManager;
}
public EnforceRetentionLimitsAction(ErrorRepository errorRepository, OrganizationRepository organizationRepository) {
_errorRepository = errorRepository;
_organizationRepository = organizationRepository;
}
public UMResponseOrganization GetOrganization(string SessionID)
{
IOrganizationRepository _IOrganizationRepository;
_IOrganizationRepository = new OrganizationRepository(new WorkersInMotionDB());
UMResponseOrganization _umResponse = new UMResponseOrganization();
//_umResponse.Organization = new MOrganization();
//if (!string.IsNullOrEmpty(SessionID))
//{
// string OrganizationGUID = _IOrganizationRepository.GetOrganizationID(SessionID);
// if (!string.IsNullOrEmpty(OrganizationGUID))
// {
// Organization org = _IOrganizationRepository.GetOrganizationByID(new Guid(OrganizationGUID));
// if (org != null)
// {
// _umResponse.Organization.OrganizationGUID = org.OrganizationGUID;
// _umResponse.Organization.OrganizationName = org.OrganizationName;
// _umResponse.Organization.OrganizationFullName = org.OrganizationFullName;
// _umResponse.Organization.Website = org.Website;
// _umResponse.Organization.Phone = org.Phone;
// // _umResponse.Organization.TimeZone = org.TimeZone;
// _umResponse.Organization.AddressLine1 = org.AddressLine1;
// _umResponse.Organization.AddressLine2 = org.AddressLine2;
// _umResponse.Organization.City = org.City;
// _umResponse.Organization.State = org.State;
// _umResponse.Organization.Country = org.Country;
// _umResponse.Organization.ZipCode = org.ZipCode;
// _umResponse.Organization.EmailID = org.EmailID;
// // _umResponse.Organization.ApplicationURL = org.ApplicationURL;
// _umResponse.Organization.IsActive = org.IsActive;
// _umResponse.Organization.IsDeleted = org.IsDeleted;
// //_umResponse.Organization.CreatedDate = org.CreatedDate;
// }
// }
//}
return _umResponse;
}
public TerritoryRegion GetTerritoryRegion(Guid UserGUID)
{
TerritoryRegion lTerritoryRegion = new TerritoryRegion();
ITerritoryRepository _ITerritoryRepository = new TerritoryRepository(new WorkersInMotionDB());
IRegionRepository _IRegionRepository = new RegionRepository(new WorkersInMotionDB());
IOrganizationRepository _IOrganizationRepository = new OrganizationRepository(new WorkersInMotionDB());
Guid OrganizationGUID = _IOrganizationRepository.GetOrganizationIDByUserGUID(UserGUID);
List<Territory> TerritoryList = _ITerritoryRepository.GetTerritoryByOrganizationGUID(OrganizationGUID).ToList();
if (TerritoryList != null && TerritoryList.Count > 0)
{
lTerritoryRegion.Territories = new List<MobileTerritory>();
foreach (Territory item in TerritoryList)
{
MobileTerritory lterritory = new MobileTerritory();
lterritory = convertTerritoryToMobileTerritory(item);
lTerritoryRegion.Territories.Add(lterritory);
}
}
List<Region> RegionList = _IRegionRepository.GetRegionByOrganizationGUID(OrganizationGUID).ToList();
if (RegionList != null && RegionList.Count > 0)
{
lTerritoryRegion.Regions = new List<MobileRegion>();
foreach (Region item in RegionList)
{
MobileRegion lregion = convertRegionToMobileRegion(item);
lTerritoryRegion.Regions.Add(lregion);
}
}
return lTerritoryRegion;
}
public ProfilesCatalogService(SPWeb clientWeb) {
Validation.ArgumentNotNull(clientWeb, "clientWeb");
this.clientWeb = clientWeb;
this.repository = new OrganizationRepository(clientWeb);
}
public UpdateStatsAction(ErrorStatsHelper statsHelper, OrganizationRepository organizationRepository, ProjectRepository projectRepository, ErrorStackRepository errorStackRepository) {
_organizationRepository = organizationRepository;
_projectRepository = projectRepository;
_errorStackRepository = errorStackRepository;
_statsHelper = statsHelper;
}
public EnforceRetentionLimitsJob(OrganizationRepository organizationRepository, ErrorRepository errorRepository) {
_organizationRepository = organizationRepository;
_errorRepository = errorRepository;
}
