public AccountController(
HttpContextBase httpContext,
IUserService userService)
: base(httpContext)
{
_userService = userService;
}
public AuthenticationController(
IFormsAuthenticationService formsAuthService,
IUserService userService)
{
FormsAuth = formsAuthService;
UserService = userService;
}
public AccountModule(IRegionManager regionManager,
IUserService userService, IApplicationState applicationState,
AccountSelectorView accountSelectorView, AccountSelectorViewModel accountSelectorViewModel,
AccountDetailsView accountDetailsView,
DocumentCreatorView documentCreatorView,
BatchDocumentCreatorView batchDocumentCreatorView, BatchDocumentCreatorViewModel batchDocumentCreatorViewModel)
: base(regionManager, AppScreens.AccountView)
{
_regionManager = regionManager;
_userService = userService;
_applicationState = applicationState;
_accountSelectorView = accountSelectorView;
_accountSelectorViewModel = accountSelectorViewModel;
_accountDetailsView = accountDetailsView;
_documentCreatorView = documentCreatorView;
_batchDocumentCreatorView = batchDocumentCreatorView;
_batchDocumentCreatorViewModel = batchDocumentCreatorViewModel;
AddDashboardCommand<EntityCollectionViewModelBase<AccountTypeViewModel, AccountType>>(Resources.AccountType.ToPlural(), Resources.Accounts, 40);
AddDashboardCommand<EntityCollectionViewModelBase<AccountViewModel, Account>>(Resources.Account.ToPlural(), Resources.Accounts, 40);
AddDashboardCommand<EntityCollectionViewModelBase<AccountScreenViewModel, AccountScreen>>(Resources.AccountScreen.ToPlural(), Resources.Accounts, 40);
AddDashboardCommand<EntityCollectionViewModelBase<AccountTransactionTypeViewModel, AccountTransactionType>>(Resources.TransactionType.ToPlural(), Resources.Accounts, 40);
AddDashboardCommand<EntityCollectionViewModelBase<AccountTransactionDocumentTypeViewModel, AccountTransactionDocumentType>>(Resources.DocumentType.ToPlural(), Resources.Accounts, 40);
AddDashboardCommand<EntityCollectionViewModelBase<AccountTransactionDocumentViewModel, AccountTransactionDocument>>(Resources.Transaction.ToPlural(), Resources.Accounts, 40);
PermissionRegistry.RegisterPermission(PermissionNames.NavigateAccountView, PermissionCategories.Navigation, Resources.CanNavigateCash);
PermissionRegistry.RegisterPermission(PermissionNames.CreateAccount, PermissionCategories.Account, Resources.CanCreateAccount);
SetNavigationCommand(Resources.Accounts, Resources.Common, "Images/Xls.png", 30);
}
public UserContext(ICurrentUserRetriever currentUserRetriever, IUserService userService)
{
Contract.Requires<ArgumentNullException>(currentUserRetriever.IsNotNull());
Contract.Requires<ArgumentNullException>(userService.IsNotNull());
this.user = new Lazy<User>(currentUserRetriever.GetCurrentUser);
this.userService = userService;
}
public ReplyViewModel(IBaconProvider baconProvider, Thing replyTargetThing, RelayCommand cancel, Action<Thing> convertIntoUIReply, bool isEdit = false)
{
_convertIntoUIReply = convertIntoUIReply;
_cancel = cancel;
_baconProvider = baconProvider;
_redditService = _baconProvider.GetService<IRedditService>();
_userService = _baconProvider.GetService<IUserService>();
_markdownProcessor = _baconProvider.GetService<IMarkdownProcessor>();
_replyTargetThing = replyTargetThing;
if (isEdit)
{
Editing = true;
EditingId = ((Comment)_replyTargetThing.Data).Name;
ReplyBody = ((Comment)_replyTargetThing.Data).Body.Replace(">", ">").Replace("<", "<");
}
RefreshUserImpl();
_addBold = new RelayCommand(AddBoldImpl);
_addItalic = new RelayCommand(AddItalicImpl);
_addStrike = new RelayCommand(AddStrikeImpl);
_addSuper = new RelayCommand(AddSuperImpl);
_addLink = new RelayCommand(AddLinkImpl);
_addQuote = new RelayCommand(AddQuoteImpl);
_addCode = new RelayCommand(AddCodeImpl);
_addBullets = new RelayCommand(AddBulletsImpl);
_addNumbers = new RelayCommand(AddNumbersImpl);
_submit = new RelayCommand(SubmitImpl);
_refreshUser = new RelayCommand(RefreshUserImpl);
}
public AuthenticationController(
OwinEnvironmentService owin,
IViewService viewService,
IUserService userService,
IdentityServerOptions idSvrOptions,
IClientStore clientStore,
IEventService eventService,
ILocalizationService localizationService,
SessionCookie sessionCookie,
MessageCookie<SignInMessage> signInMessageCookie,
MessageCookie<SignOutMessage> signOutMessageCookie,
LastUserNameCookie lastUsernameCookie,
AntiForgeryToken antiForgeryToken)
{
this.context = new OwinContext(owin.Environment);
this.viewService = viewService;
this.userService = userService;
this.options = idSvrOptions;
this.clientStore = clientStore;
this.eventService = eventService;
this.localizationService = localizationService;
this.sessionCookie = sessionCookie;
this.signInMessageCookie = signInMessageCookie;
this.signOutMessageCookie = signOutMessageCookie;
this.lastUsernameCookie = lastUsernameCookie;
this.antiForgeryToken = antiForgeryToken;
}
public UsersController(IUserService service, IPlansService service2, ICMSService service3)
: base(service)
{
this._userService = service;
this._plansService = service2;
this._cmsService = service3;
}
public ModifierModule(IRegionManager regionManager, IUserService userService,
ExtraModifierEditorView extraModifierEditorView, ExtraModifierEditorViewModel extraModifierEditorViewModel,
TicketNoteEditorView ticketNoteEditorView, TicketNoteEditorViewModel ticketNoteEditorViewModel,
TicketTagEditorView ticketTagEditorView, TicketTagEditorViewModel ticketTagEditorViewModel,
OrderTagEditorView selectedOrdersView, OrderTagEditorViewModel selectedOrdersViewModel)
{
_selectedOrdersView = selectedOrdersView;
_selectedOrdersViewModel = selectedOrdersViewModel;
_ticketNoteEditorView = ticketNoteEditorView;
_ticketNoteEditorViewModel = ticketNoteEditorViewModel;
_ticketTagEditorView = ticketTagEditorView;
_ticketTagEditorViewModel = ticketTagEditorViewModel;
_extraModifierEditorViewModel = extraModifierEditorViewModel;
_extraModifierEditorView = extraModifierEditorView;
_regionManager = regionManager;
_userService = userService;
EventServiceFactory.EventService.GetEvent<GenericEvent<SelectedOrdersData>>().Subscribe(OnSelectedOrdersDataEvent);
EventServiceFactory.EventService.GetEvent<GenericEvent<EventAggregator>>().Subscribe(OnDisplayTicketDetailsScreen);
EventServiceFactory.EventService.GetEvent<GenericEvent<TicketTagData>>().Subscribe(OnTicketTagDataSelected);
EventServiceFactory.EventService.GetEvent<GenericEvent<Ticket>>().Subscribe(OnTicketEvent);
_showExtraModifierCommand = new CaptionCommand<Ticket>(Resources.ExtraModifier, OnExtraModifiersSelected, CanSelectExtraModifier);
_showExtraModifierCommand.PublishEvent(EventTopicNames.AddCustomOrderCommand);
}
public DefaultTokenService(IUserService users, ICoreSettings settings, IClaimsProvider claimsProvider, ITokenHandleStore tokenHandles)
{
_users = users;
_settings = settings;
_claimsProvider = claimsProvider;
_tokenHandles = tokenHandles;
}
public async Task<AuthenticationResult> Authenticate(Dictionary<string, string> authenticationCtx, IUserService userService)
{
if (authenticationCtx["provider"] != Provider_Name)
{
return null;
}
string ticket;
if (!authenticationCtx.TryGetValue("ticket", out ticket) || string.IsNullOrWhiteSpace(ticket))
{
return AuthenticationResult.CreateFailure("Steam session ticket must not be empty.", Provider_Name, authenticationCtx);
}
var steamId = await _authenticator.AuthenticateUserTicket(ticket);
if (!steamId.HasValue)
{
return AuthenticationResult.CreateFailure("Invalid steam session ticket.", Provider_Name, authenticationCtx);
}
var steamIdString = steamId.GetValueOrDefault().ToString();
var user = await userService.GetUserByClaim(Provider_Name, ClaimPath, steamIdString);
if (user == null)
{
var uid = Provider_Name + "-" + steamIdString;
user = await userService.CreateUser(uid, new JObject());
user = await userService.AddAuthentication(user, Provider_Name, JObject.FromObject(new { CLAIMPATH = steamIdString }));
}
return AuthenticationResult.CreateSuccess(user, Provider_Name, authenticationCtx);
}
public void SetUp()
{
userRepository = new Mock<IUserRepository>();
userProfileRepository = new Mock<IUserProfileRepository>();
followRequestRepository = new Mock<IFollowRequestRepository>();
followUserRepository = new Mock<IFollowUserRepository>();
securityTokenRepository = new Mock<ISecurityTokenRepository>();
unitOfWork = new Mock<IUnitOfWork>();
userService = new UserService(userRepository.Object, unitOfWork.Object, userProfileRepository.Object);
userProfileService = new UserProfileService(userProfileRepository.Object, unitOfWork.Object);
followRequestService = new FollowRequestService(followRequestRepository.Object, unitOfWork.Object);
followUserService = new FollowUserService(followUserRepository.Object, unitOfWork.Object);
securityTokenService = new SecurityTokenService(securityTokenRepository.Object, unitOfWork.Object);
controllerContext = new Mock<ControllerContext>();
contextBase = new Mock<HttpContextBase>();
httpRequest = new Mock<HttpRequestBase>();
httpResponse = new Mock<HttpResponseBase>();
genericPrincipal = new Mock<GenericPrincipal>();
httpSession = new Mock<HttpSessionStateBase>();
authentication = new Mock<IFormsAuthentication>();
identity = new Mock<IIdentity>();
principal = new Mock<IPrincipal>();
tempData = new Mock<TempDataDictionary>();
file = new Mock<HttpPostedFileBase>();
stream = new Mock<Stream>();
accountController = new Mock<AccountController>();
}
public HomeController(
IAuditService<User, UserAudit> auditService,
IUserService userService)
{
this.AuditService = auditService;
this.UserService = userService;
}
public PackagesController(
IPackageService packageService,
IUploadFileService uploadFileService,
IUserService userService,
IMessageService messageService,
ISearchService searchService,
IAutomaticallyCuratePackageCommand autoCuratedPackageCmd,
INuGetExeDownloaderService nugetExeDownloaderService,
IPackageFileService packageFileService,
IEntitiesContext entitiesContext,
IAppConfiguration config,
IIndexingService indexingService,
ICacheService cacheService)
{
_packageService = packageService;
_uploadFileService = uploadFileService;
_userService = userService;
_messageService = messageService;
_searchService = searchService;
_autoCuratedPackageCmd = autoCuratedPackageCmd;
_nugetExeDownloaderService = nugetExeDownloaderService;
_packageFileService = packageFileService;
_entitiesContext = entitiesContext;
_config = config;
_indexingService = indexingService;
_cacheService = cacheService;
}
public CachedUserService(IUserService userService, ICacheProvider cacheProvider, IUserStorePathProvider userStorePathProvider)
{
_userService = userService;
_cacheProvider = cacheProvider;
_optoutCacheFileName = userStorePathProvider.GetOptoutFileName();
_optinCacheFileName = userStorePathProvider.GetOptinFileName();
}
public ApiController(
IEntitiesContext entitiesContext,
IPackageService packageService,
IPackageFileService packageFileService,
IUserService userService,
INuGetExeDownloaderService nugetExeDownloaderService,
IContentService contentService,
IIndexingService indexingService,
ISearchService searchService,
IAutomaticallyCuratePackageCommand autoCuratePackage,
IStatusService statusService,
IAppConfiguration config)
{
EntitiesContext = entitiesContext;
PackageService = packageService;
PackageFileService = packageFileService;
UserService = userService;
NugetExeDownloaderService = nugetExeDownloaderService;
ContentService = contentService;
StatisticsService = null;
IndexingService = indexingService;
SearchService = searchService;
AutoCuratePackage = autoCuratePackage;
StatusService = statusService;
_config = config;
}
/// <summary>
/// Initializes a new instance of the <see cref="CmsMembershipProvider" /> class.
/// </summary>
/// <param name="userService">The user service.</param>
/// <param name="authenticationService">The authentication service.</param>
/// <param name="unitOfWork">The unit of work.</param>
/// <param name="membershipName">Name of the membership.</param>
internal CmsMembershipProvider(IUserService userService, IAuthenticationService authenticationService, IUnitOfWork unitOfWork, string membershipName)
{
this.authenticationService = authenticationService;
this.userService = userService;
this.unitOfWork = unitOfWork;
this.membershipName = membershipName;
}
public DepartmentSelectorView(IApplicationStateSetter applicationStateSetter, IApplicationState applicationState,
IUserService userService, ICacheService cacheService)
{
InitializeComponent();
_applicationStateSetter = applicationStateSetter;
DataContext = new DepartmentSelectorViewModel(applicationState, _applicationStateSetter, userService, cacheService);
}
public AccountModule(IRegionManager regionManager,
IUserService userService,
AccountSelectorView accountSelectorView,
AccountDetailsView accountDetailsView,
DocumentCreatorView documentCreatorView)
: base(regionManager, AppScreens.AccountList)
{
_regionManager = regionManager;
_userService = userService;
_accountSelectorView = accountSelectorView;
_accountDetailsView = accountDetailsView;
_documentCreatorView = documentCreatorView;
AddDashboardCommand<EntityCollectionViewModelBase<AccountTemplateViewModel, AccountTemplate>>(Resources.AccountTemplate.ToPlural(), Resources.Accounts, 40);
AddDashboardCommand<EntityCollectionViewModelBase<AccountViewModel, Account>>(Resources.Account.ToPlural(), Resources.Accounts, 40);
AddDashboardCommand<EntityCollectionViewModelBase<AccountScreenViewModel, AccountScreen>>(Resources.AccountScreen.ToPlural(), Resources.Accounts, 40);
AddDashboardCommand<EntityCollectionViewModelBase<AccountTransactionTemplateViewModel, AccountTransactionTemplate>>(Resources.TransactionTemplate.ToPlural(), Resources.Accounts, 40);
AddDashboardCommand<EntityCollectionViewModelBase<AccountTransactionDocumentViewModel, AccountTransactionDocument>>(Resources.TransactionDocument.ToPlural(), Resources.Accounts, 40);
AddDashboardCommand<EntityCollectionViewModelBase<AccountTransactionDocumentTemplateViewModel, AccountTransactionDocumentTemplate>>(Resources.DocumentTemplate.ToPlural(), Resources.Accounts, 40);
PermissionRegistry.RegisterPermission(PermissionNames.NavigateAccountView, PermissionCategories.Navigation, Resources.CanNavigateCash);
PermissionRegistry.RegisterPermission(PermissionNames.MakeAccountTransaction, PermissionCategories.Cash, Resources.CanMakeAccountTransaction);
PermissionRegistry.RegisterPermission(PermissionNames.CreditOrDeptAccount, PermissionCategories.Cash, Resources.CanMakeCreditOrDeptTransaction);
PermissionRegistry.RegisterPermission(PermissionNames.CreateAccount, PermissionCategories.Account, Resources.CanCreateAccount);
SetNavigationCommand(Resources.Accounts, Resources.Common, "Images/Xls.png", 70);
}
public static void MyClassInitialize(TestContext testContext)
{
container = TestManager.ConfigureUnityContainer("unity");
UserService = container.Resolve<IUserService>();
GroupService = container.Resolve<IGroupService>();
}
public UserController(
IUserService userService,
IFormsAuthenticationService formsAuthenticationService)
{
_formsAuthenticationService = formsAuthenticationService;
_userService = userService;
}
public ImportController() {
templateService = new SpiderTemplateService();
importService = new SportImportService();
spiderTool = new SpiderTool();
appService = new SiteAppService();
userService = new UserService();
}
//public static ClientValidator CreateClientValidator(
// IClientStore clients = null,
// IClientSecretValidator secretValidator = null)
//{
// if (clients == null)
// {
// clients = new InMemoryClientStore(ClientValidationTestClients.Get());
// }
// if (secretValidator == null)
// {
// secretValidator = new HashedClientSecretValidator();
// }
// var owin = new OwinEnvironmentService(new OwinContext());
// return new ClientValidator(clients, secretValidator, owin);
//}
public static TokenRequestValidator CreateTokenRequestValidator(
IdentityServerOptions options = null,
IScopeStore scopes = null,
IAuthorizationCodeStore authorizationCodeStore = null,
IRefreshTokenStore refreshTokens = null,
IUserService userService = null,
IEnumerable<ICustomGrantValidator> customGrantValidators = null,
ICustomRequestValidator customRequestValidator = null,
ScopeValidator scopeValidator = null)
{
if (options == null)
{
options = TestIdentityServerOptions.Create();
}
if (scopes == null)
{
scopes = new InMemoryScopeStore(TestScopes.Get());
}
if (userService == null)
{
userService = new TestUserService();
}
if (customRequestValidator == null)
{
customRequestValidator = new DefaultCustomRequestValidator();
}
CustomGrantValidator aggregateCustomValidator;
if (customGrantValidators == null)
{
aggregateCustomValidator = new CustomGrantValidator(new [] { new TestGrantValidator() });
}
else
{
aggregateCustomValidator = new CustomGrantValidator(customGrantValidators);
}
if (refreshTokens == null)
{
refreshTokens = new InMemoryRefreshTokenStore();
}
if (scopeValidator == null)
{
scopeValidator = new ScopeValidator(scopes);
}
return new TokenRequestValidator(
options,
authorizationCodeStore,
refreshTokens,
userService,
aggregateCustomValidator,
customRequestValidator,
scopeValidator,
new DefaultEventService());
}
public AuthenticationController(
IFormsAuthenticationService formsAuthSvc,
IUserService userSvc)
{
this.formsAuthSvc = formsAuthSvc;
this.userSvc = userSvc;
}
public UserModule(IUserService userService):base("/users")
{
Get["/{id}", true] = async (ctx, cancel) =>
{
var request = this.Bind<GetUserByIdRequest>();
var user = await userService.GetUserById(new GetUserById()
{
Id = request.Id
});
return Response.AsJson(user);
};
Post["/", true] = async (ctx, cancel) =>
{
var request = this.Bind<CreateUserRequest>();
var user = await userService.CreateUser(new CreateUser()
{
HourlyRate = request.HourlyRate,
Salary = request.Salary
});
return Response.AsJson(user);
};
}
public UserController(IUserRepository userRepository
, IUserService userService
)
{
_userRepository = userRepository;
_userService = userService;
}
public UserRoleController(CoreSettings coreSettings, IPermissionService permissionService, IUserService userService, IWorkContext workContext)
{
_coreSettings = coreSettings;
_permissionService = permissionService;
_userService = userService;
_workContext = workContext;
}
public MemberController(IMemberService memberService, IUserService userService, IRoleService roleService, ILevelService levelService)
{
_memberService = memberService;
_userService = userService;
_roleService = roleService;
_levelService = levelService;
}
public UsersController(
ScimServerConfiguration serverConfiguration,
IUserService userService)
: base(serverConfiguration)
{
_UserService = userService;
}
public void SetUp()
{
// you have to be an administrator to access the product controller
Thread.CurrentPrincipal = new GenericPrincipal(new GenericIdentity("admin"), new[] { "Administrator" });
categoryRepository = MockRepositoryBuilder.CreateCategoryRepository();
productRepository = MockRepositoryBuilder.CreateProductRepository();
productOrderableService = MockRepository.GenerateStub<IOrderableService<ProductCategory>>();
MockRepository.GenerateStub<IOrderableService<ProductImage>>();
userService = MockRepository.GenerateStub<IUserService>();
productBuilder = MockRepository.GenerateStub<IProductBuilder>();
productController = new ProductController(
productRepository,
categoryRepository,
productOrderableService,
userService,
MockRepository.GenerateStub<IUnitOfWorkManager>(),
productBuilder);
userService.Stub(c => c.CurrentUser).Return(new User { Role = Role.Administrator });
}
public AccountController(IDbConnection db, IMetricTracker metrics, ICacheClient cache, IMailController mailController, IUserService userService, IUserAuthenticationService authenticationService)
: base(db, metrics, cache)
{
_mailController = mailController;
_userService = userService;
_authenticationService = authenticationService;
}
public UserController(IUserService userservice, IMapper mapper, UserManager <User> userManager)
{
_userService = userservice;
_mapper = mapper;
_userManager = userManager;
}
public UserController(IUserService userService)
{
this.userService = userService;
}
public QuoteService(IMapper mapper, SPNDbContext dbContext, IReplyService replyService, IUserService userService)
: base(mapper, dbContext)
{
this.replyService = replyService;
this.userService = userService;
}
public SeedService(IUserService userService, IRoleService roleService, IPermissionService permissionService)
{
_userService = userService;
_roleService = roleService;
_permissionService = permissionService;
}
public HealUserModel(IUserService userService)
{
_userService = userService;
}
public UserAppService(IUserService _service)
: base(_service)
{
service = _service;
}
public LoginController(IUserService userService)
{
_userService = userService;
}
public AuthManager(IUserService userService, ITokenHelper tokenHelper)
{
_userService = userService;
_tokenHelper = tokenHelper;
}
public RegisterModel(IUserService service)
{
_service = service;
}
public FaqApplicationService(IFaqDomainService domainService, IMapper mapper, IAuthorizationService authorizationService, IUserService userService, IHubContext <ApiNotificationHub <FaqDto> > hubContext)
: base("cms.faqs.", domainService, mapper, authorizationService, userService, hubContext)
{
}
public UsersController(IUserService service)
{
_service = service;
}
public UserController(IUserService userService)
{
_userService = userService;
}
public TokenController(
IUserService userService)
{
_userService = userService;
}
public GroupsController(IGroupService groupService, IUserService userService)
{
this.groupService = groupService;
this.userService = userService;
}
public LoginViewModel(IUserService userService)
{
_userService = userService;
}
public PrintFriendsListCommand(IUserService userService)
{
this.userService = userService;
}
public UserManagementController(ICommandBus commandBus, IUserService userService)
: base(commandBus)
{
this.userService = userService;
}
public ArticleService(ICategoryService categoryService, IArticleRepository articleRepository, IRoleService roleService, ISettingService settingService, IUserService userService)
{
_userService = userService;
_articleRepository = articleRepository;
_roleService = roleService;
_settingService = settingService;
_categoryService = categoryService;
}
public UserUnitTest()
{
_userService = new UserService();
}
public AccountController(IUserService userService)
{
_userService = userService;
}
public CompanyController(ICompanyService companyService, IProjectService projectService, IUserService userService, UserManager <ApplicationUser> userManager, RoleManager <IdentityRole> roleManager, SignInManager <ApplicationUser> signInManager)
{
this.companyService = companyService;
this.projectService = projectService;
this.userService = userService;
this.userManager = userManager;
this.roleManager = roleManager;
this.signInManager = signInManager;
}
public Tenant1Controller(IUserService service) : base(service)
{
}
internal static async Task <HttpResponseMessage> PostSetAvatarInternal(HttpRequestMessage request, IUserService userService, IAppCache cache, int id)
{
if (request.Content.IsMimeMultipartContent() == false)
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
var root = IOHelper.MapPath(SystemDirectories.TempFileUploads);
//ensure it exists
Directory.CreateDirectory(root);
var provider = new MultipartFormDataStreamProvider(root);
var result = await request.Content.ReadAsMultipartAsync(provider);
//must have a file
if (result.FileData.Count == 0)
{
return(request.CreateResponse(HttpStatusCode.NotFound));
}
var user = userService.GetUserById(id);
if (user == null)
{
return(request.CreateResponse(HttpStatusCode.NotFound));
}
var tempFiles = new PostedFiles();
if (result.FileData.Count > 1)
{
return(request.CreateValidationErrorResponse("The request was not formatted correctly, only one file can be attached to the request"));
}
//get the file info
var file = result.FileData[0];
var fileName = file.Headers.ContentDisposition.FileName.Trim(new[] { '\"' }).TrimEnd();
var safeFileName = fileName.ToSafeFileName();
var ext = safeFileName.Substring(safeFileName.LastIndexOf('.') + 1).ToLower();
if (Current.Configs.Settings().Content.DisallowedUploadFiles.Contains(ext) == false)
{
//generate a path of known data, we don't want this path to be guessable
user.Avatar = "UserAvatars/" + (user.Id + safeFileName).GenerateHash <SHA1>() + "." + ext;
using (var fs = System.IO.File.OpenRead(file.LocalFileName))
{
Current.MediaFileSystem.AddFile(user.Avatar, fs, true);
}
userService.Save(user);
//track the temp file so the cleanup filter removes it
tempFiles.UploadedFiles.Add(new ContentPropertyFile
{
TempFilePath = file.LocalFileName
});
}
return(request.CreateResponse(HttpStatusCode.OK, user.GetUserAvatarUrls(cache)));
}
public AuthenticationService(IConfigFileProvider configFileProvider, IUserService userService)
{
_userService = userService;
API_KEY = configFileProvider.ApiKey;
AUTH_METHOD = configFileProvider.AuthenticationMethod;
}
public UserExistsAttribute(IUserService userService)
{
_userService = userService;
}
/// <summary>
/// Initializes the ProfileController
/// </summary>
/// <param name="groupService"></param>
/// <param name="userService"></param>
public ProfileController(IGroupService groupService, IUserService userService)
{
GroupService = groupService;
UserService = userService;
}
public TableItemController(ITableService tableService, IOrderService orderService, IOrderItemService orderItemService, IUserService userService, IProductService productService, ITableItemService tableItemService)
{
this.tableService = tableService;
this.orderService = orderService;
this.orderItemService = orderItemService;
this.userService = userService;
this.productService = productService;
this.tableItemService = tableItemService;
}
public AdminAPIController(IAdminService _HomeService, IManageAdminService manageAdminService, IPreferenceService prefenceService, IUserService userService)
{
_adminService = _HomeService;
_manageAdminService = manageAdminService;
_prefenceService = prefenceService;
_userService = userService;
}
public InvitesController(IMapper mapper, IFriendService friendService, IUserService userService)
{
this.mapper = mapper;
this.friendService = friendService;
this.userService = userService;
}
public UserController(IUserService userService, IUserProfileService userProfileService)
{
this.userService = userService;
this.userProfileService = userProfileService;
}
