public async Task <IHttpActionResult> Authenticate(CredentialsDTO credentials)
{
Fr8AccountDO account;
TerminalDO terminalDO;
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
terminalDO = _terminal.GetByNameAndVersion(credentials.Terminal.Name, credentials.Terminal.Version);
account = _security.GetCurrentAccount(uow);
}
var response = await _authorization.AuthenticateInternal(
account,
terminalDO,
credentials.Domain,
credentials.Username,
credentials.Password,
credentials.IsDemoAccount
);
return(Ok(new TokenResponseDTO
{
TerminalId = response.AuthorizationToken?.TerminalID,
TerminalName = terminalDO.Name,
AuthTokenId = response.AuthorizationToken?.Id.ToString(),
Error = response.Error
}));
}
/// <summary>
/// Create Subroute entity.
/// </summary>
public void Create(IUnitOfWork uow, SubplanDO subplan)
{
if (subplan == null)
{
throw new ArgumentNullException(nameof(subplan));
}
subplan.Fr8Account = _security.GetCurrentAccount(uow);
subplan.CreateDate = DateTime.UtcNow;
subplan.LastUpdated = subplan.CreateDate;
var curPlan = uow.PlanRepository.GetById <PlanDO>(subplan.RootPlanNodeId);
if (curPlan == null)
{
throw new MissingObjectException($"Plan with Id {subplan.RootPlanNodeId} doesn't exist");
}
var curPlanNode = uow.PlanRepository.GetById <PlanNodeDO>(subplan.ParentPlanNodeId);
if (curPlanNode == null)
{
throw new MissingObjectException($"Parent plan-node with Id {subplan.ParentPlanNodeId} doesn't exist");
}
subplan.RootPlanNode = curPlan;
subplan.ParentPlanNode = curPlanNode;
curPlanNode.AddChildWithDefaultOrdering(subplan);
}
protected Fr8AccountDO GetUserTerminalOperatesOn()
{
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
return(_security.GetCurrentAccount(uow));
}
}
//This method finds and returns single SolutionPageDTO that holds some documentation of Activities that is obtained from a solution by aame
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="activityDTO"></param>
/// <param name="isSolution">This parameter controls the access level: if it is a solution case
/// we allow calls without CurrentAccount; if it is not - we need a User to get the list of available activities</param>
/// <returns>Task<DocumentationResponseDTO></returns>
public async Task <T> GetActivityDocumentation <T>(ActivityDTO activityDTO, bool isSolution = false) where T : class
{
//activityResponce can be either of type SolutoinPageDTO or ActivityRepsonceDTO
T activityResponce;
var userId = Guid.NewGuid().ToString();
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
var allActivityTemplates = ObjectFactory.GetInstance <IEnumerable <ActivityTemplateDTO> >();
if (isSolution)
{
//Get the list of all actions that are solutions from database
allActivityTemplates = _planNode.GetSolutions(uow);
}
else
{
var curUser = _security.GetCurrentAccount(uow);
userId = curUser.Id;
allActivityTemplates = _planNode.GetAvailableActivities(uow, curUser);
}
//find the activity by the provided name
// To prevent mismatch between db and terminal solution lists, Single or Default used
var curActivityTerminalDTO = allActivityTemplates
.OrderByDescending(x => int.Parse(x.Version))
.FirstOrDefault(a => a.Name == activityDTO.ActivityTemplate.Name);
//prepare an Activity object to be sent to Activity in a Terminal
//IMPORTANT: this object will not be hold in the database
//It is used to transfer data
//as ActivityDTO is the first mean of communication between The Hub and Terminals
// Since there can be mismatched data between db and terminal solution list, we should make a null check here
if (curActivityTerminalDTO == null)
{
return(null);
}
var curActivityDTO = new ActivityDTO
{
Id = Guid.NewGuid(),
Label = curActivityTerminalDTO.Label,
ActivityTemplate = new ActivityTemplateSummaryDTO
{
Name = curActivityTerminalDTO.Name,
Version = curActivityTerminalDTO.Version,
TerminalName = curActivityTerminalDTO.Terminal.Name,
TerminalVersion = curActivityTerminalDTO.Terminal.Version
},
AuthToken = new AuthorizationTokenDTO
{
UserId = null
},
Documentation = activityDTO.Documentation
};
activityResponce = await GetDocumentation <T>(curActivityDTO);
}
return(activityResponce);
}
public IHttpActionResult Get()
{
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
IList <ContainerDO> curContainer = _containerService
.GetByFr8Account(
uow,
_security.GetCurrentAccount(uow),
_security.IsCurrentUserHasRole(Roles.Admin),
null
);
if (curContainer.Any())
{
return(Ok(curContainer.Select(Mapper.Map <ContainerDTO>)));
}
return(Ok());
}
}
private async Task <IHttpActionResult> CreateSolution(string solutionName)
{
var userId = User.Identity.GetUserId();
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
ActivityTemplateDO activityTemplate;
var activityTemplateInfo = _activityTemplate.GetActivityTemplateInfo(solutionName);
if (!string.IsNullOrEmpty(activityTemplateInfo.Version))
{
activityTemplate = _activityTemplate
.GetQuery()
.FirstOrDefault(x => x.Name == activityTemplateInfo.Name && x.Version == activityTemplateInfo.Version);
}
else
{
activityTemplate = _activityTemplate.GetQuery()
.Where(x => x.Name == solutionName)
.AsEnumerable()
.OrderByDescending(x => int.Parse(x.Version))
.FirstOrDefault();
}
if (activityTemplate == null)
{
throw new MissingObjectException($"Activity template (solution) name {solutionName} doesn't exist");
}
ObjectFactory.GetInstance <ITracker>().Track(_security.GetCurrentAccount(uow), "Loaded Solution", new Segment.Model.Properties().Add("Solution Name", solutionName));
var result = await _activity.CreateAndConfigure(
uow,
userId,
activityTemplate.Id,
name : activityTemplate.Label,
createPlan : true);
return(Ok(PlanMappingHelper.MapPlanToDto((PlanDO)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 Details(int id)
{
FileDTO fileDto = null;
if (_security.IsCurrentUserHasRole(Roles.Admin))
{
fileDto = Mapper.Map <FileDTO>(_fileService.GetFileByAdmin(id));
}
else
{
string userId;
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
userId = _security.GetCurrentAccount(uow).Id;
}
fileDto = Mapper.Map <FileDTO>(_fileService.GetFile(id, userId));
}
return(Ok(fileDto));
}
public void CreateOrUpdate(IUnitOfWork uow, PlanDO submittedPlan)
{
if (submittedPlan.Id == Guid.Empty)
{
submittedPlan.Id = Guid.NewGuid();
submittedPlan.PlanState = PlanState.Inactive;
submittedPlan.Fr8Account = _security.GetCurrentAccount(uow);
if (string.IsNullOrEmpty(submittedPlan.Name))
{
submittedPlan.Name = "Untitled Plan " + (UserPlansCount(uow, _security.GetCurrentUser()) + 1);
}
submittedPlan.ChildNodes.Add(new SubplanDO(true)
{
Id = Guid.NewGuid(),
Name = "Starting Subplan"
});
uow.PlanRepository.Add(submittedPlan);
}
else
{
var curPlan = uow.PlanRepository.GetById <PlanDO>(submittedPlan.Id);
if (curPlan == null)
{
throw new EntityNotFoundException();
}
curPlan.Name = submittedPlan.Name;
curPlan.Description = submittedPlan.Description;
curPlan.Category = submittedPlan.Category;
curPlan.LastUpdated = DateTimeOffset.UtcNow;
curPlan.IsApp = submittedPlan.IsApp;
curPlan.AppLaunchURL = submittedPlan.AppLaunchURL;
}
}
public PagedResultDTO <T> GetHistory <T, TS>(IUnitOfWork uow, PagedQueryDTO pagedQueryDto, IQueryable <TS> historyQuery) where T : HistoryItemDTO where TS : HistoryItemDO
{
ValidateInputQuery(ref pagedQueryDto);
//get the current account
var curAccount = _security.GetCurrentAccount(uow);
var filteredResult = FilterHistoryItems(historyQuery, pagedQueryDto, curAccount);
var totalItemCountForCurrentCriterias = filteredResult.Count();
filteredResult = filteredResult.Page(pagedQueryDto.Page.Value, pagedQueryDto.ItemPerPage.Value);
return(new PagedResultDTO <T>()
{
Items = filteredResult.ToList().Select(Mapper.Map <T>).ToList(),
CurrentPage = pagedQueryDto.Page.Value,
TotalItemCount = totalItemCountForCurrentCriterias
});
}
public bool IsCurrentUserInAdminRole()
{
ISecurityServices _security = ObjectFactory.GetInstance <ISecurityServices>();
bool isAdmin = false;
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
//get the current account
var curAccount = _security.GetCurrentAccount(uow);
//get the roles to check if the account has admin role
var curAccountRoles = curAccount.Roles;
//get the role id
var adminRoleId = uow.AspNetRolesRepository.GetQuery().Single(r => r.Name == Roles.Admin).Id;
//provide all facts if the user has admin role
if (curAccountRoles.Any(x => x.RoleId == adminRoleId))
{
isAdmin = true;
}
}
return(isAdmin);
}
public IHttpActionResult Get()
{
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
if (_securityServices.UserHasPermission(PermissionType.ManageFr8Users, nameof(Fr8AccountDO)))
{
Expression <Func <Fr8AccountDO, bool> > predicate = x => true;
return(Ok(GetUsers(uow, predicate)));
}
int?organizationId;
if (_securityServices.UserHasPermission(PermissionType.ManageInternalUsers, nameof(Fr8AccountDO)))
{
var currentUser = _securityServices.GetCurrentAccount(uow);
organizationId = currentUser.OrganizationId;
Expression <Func <Fr8AccountDO, bool> > predicate = x => x.OrganizationId == organizationId;
return(Ok(GetUsers(uow, predicate)));
}
//todo: show not authorized messsage in activityStream.
return(Ok(new List <UserDTO>(0)));
}
}
public IList <FactDO> GetByObjectId(IUnitOfWork unitOfWork, string id)
{
//here we should determine type of ObjectId, to look at it`s owner in appropriate table
//but it is non trivial action so for now select facts where userid is the same as fr8UserId
if (_securityServices.IsCurrentUserHasRole(Data.States.Roles.Admin))
{
return
(unitOfWork.FactRepository.GetQuery().Where(
fact =>
fact.ObjectId == id
).ToList());
}
else
{
var fr8UserId = _securityServices.GetCurrentAccount(unitOfWork).Id;
return
(unitOfWork.FactRepository.GetQuery().Where(
fact =>
fact.ObjectId == id &&
fact.Fr8UserId.Equals(fr8UserId, StringComparison.InvariantCultureIgnoreCase))
.ToList());
}
}
