public IEnumerable <ActivityTemplateCategoryDTO> GetAvailableActivityGroups()
{
var availableTerminalIds = _terminal.GetAll().Select(x => x.Id).ToList();
var activityTemplates = _activityTemplate
.GetQuery()
.Where(at => at.ActivityTemplateState == ActivityTemplateState.Active &&
availableTerminalIds.Contains(at.TerminalId)).AsEnumerable().ToArray()
.ToList();
var result = ActivityCategories.ActivityCategoryList
.Where(x => activityTemplates.Any(y => y.Categories.Any(z => z.ActivityCategoryId == x.Id) &&
y.ActivityTemplateState == ActivityTemplateState.Active))
.Select(x => new ActivityTemplateCategoryDTO()
{
Name = x.Name,
Activities = activityTemplates
.Where(y => y.Categories.Any(z => z.ActivityCategoryId == x.Id) &&
y.ActivityTemplateState == ActivityTemplateState.Active)
.GroupBy(y => y.Name)
.Select(y => y.OrderByDescending(z => int.Parse(z.Version)).First())
.Select(Mapper.Map <ActivityTemplateDTO>)
.ToList()
})
.ToList();
return(result);
}
public IHttpActionResult Get()
{
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
var currentUser = _security.GetCurrentAccount(uow);
var models = _terminal.GetAll()
.Where(u => u.UserDO != null && u.UserDO.Id == currentUser.Id)
.Select(Mapper.Map <TerminalDTO>)
.ToList();
return(Ok(models));
}
}
public IHttpActionResult UserTokens()
{
var terminals = _terminal.GetAll();
var authTokens = _authorization.GetAllTokens(User.Identity.GetUserId());
var groupedTerminals = terminals
.Where(x => authTokens.Any(y => y.TerminalID == x.Id))
.OrderBy(x => x.Name)
.AsEnumerable()
.Select(x => new AuthenticationTokenTerminalDTO
{
Id = x.Id,
Name = x.Name,
Label = x.Label,
AuthTokens = authTokens
.Where(y => y.TerminalID == x.Id && !string.IsNullOrEmpty(y.ExternalAccountId))
.Select(y => new AuthenticationTokenDTO
{
Id = y.Id,
ExternalAccountName = y.DisplayName,
IsMain = y.IsMain
})
.OrderBy(y => y.ExternalAccountName)
.ToList(),
AuthenticationType = x.AuthenticationType,
Version = x.Version
})
.ToList();
return(Ok(groupedTerminals));
}
public IEnumerable <ActivityTemplateDO> GetQuery()
{
Initialize();
lock (_activityTemplates)
{
var availableTerminalIds = _terminal.GetAll().Select(x => x.Id).ToList();
return(_activityTemplates.Values.Where(x => availableTerminalIds.Contains(x.TerminalId)));
}
}
public IEnumerable <TerminalDO> GetAll()
{
return(_terminal.GetAll());
}
public async Task <ActionResult> ProcessSuccessfulOAuthResponse(
string terminalName,
string terminalVersion,
string state = null)
{
//Here state is optional and is designed to pass auth token external state (to identify token in database) in case 3rd party service doesn't return unknown parameters contained in URL back
if (string.IsNullOrEmpty(terminalName) || string.IsNullOrEmpty(terminalVersion))
{
throw new ApplicationException("TerminalName or TerminalVersion is not specified.");
}
var requestQueryString = Request.Url.Query;
if (!string.IsNullOrEmpty(requestQueryString) && requestQueryString[0] == '?')
{
requestQueryString = requestQueryString.Substring(1);
var queryDictionary = System.Web.HttpUtility.ParseQueryString(requestQueryString);
if (queryDictionary["error"] != null && queryDictionary["error"] == "access_denied")
{
//user has denied access for our app, so close the window
dynamic model = new ExpandoObject();
model.AuthorizationTokenId = string.Empty;
model.TerminalId = 0;
model.TerminalName = string.Empty;
return(View(model));
}
if (!string.IsNullOrEmpty(state) && queryDictionary["state"] == null)
{
requestQueryString = $"{requestQueryString}&state={state}";
}
}
TerminalDO terminal = _terminal.GetAll().FirstOrDefault(x => x.Name == terminalName && x.Version == terminalVersion);
if (terminal == null)
{
throw new ApplicationException("Could not find terminal.");
}
string userId = null;
// It is unlikely that ASP cookies/headers/other stuff that is used to track current session will be send within auth callback from external service
// We need a smarter approach
/*using (var uow = ObjectFactory.GetInstance<IUnitOfWork>())
* {
* userId = _security.GetCurrentAccount(uow).Id;
* }*/
var externalAuthenticationDTO = new ExternalAuthenticationDTO()
{
RequestQueryString = requestQueryString,
Fr8UserId = userId
};
var response = await _authorization.GetOAuthToken(terminal, externalAuthenticationDTO);
if (string.IsNullOrEmpty(response.Error))
{
dynamic model = new ExpandoObject();
model.AuthorizationTokenId = response.AuthorizationToken.Id;
model.TerminalId = response.AuthorizationToken.TerminalID;
model.TerminalName = terminal.Name;
if (response.AuthorizationToken.ExternalAccountId == "*****@*****.**")
{
EventManager.TerminalAuthenticationCompleted(response.AuthorizationToken.UserId, terminal, response.AuthorizationToken);
}
return(View(model));
}
else
{
EventManager.OAuthAuthenticationFailed(requestQueryString, response.Error);
return(View("Error", new AuthenticationErrorVM()
{
Error = response.Error
}));
}
}
public async Task DiscoverAll()
{
var discoverTerminalsTasks = _terminal.GetAll().Select(x => DiscoverInternal(x, false)).ToArray();
await Task.WhenAll(discoverTerminalsTasks);
}