public void Init()
{
var testDataModel = new TestDataModel();
list = new ActivitiesList(testDataModel.MockDataModel.Object);
test = list.Create();
}
internal async Task <string> AddActivity()
{
if (NewActivityDescription == "")
{
return("Activity's description can't be empty");
}
else if (NewActivityStart == null)
{
return("Activity's daycan't be empty");
}
else if (NewActivityStart < Travel.Start || NewActivityStart > Travel.End)
{
return("The activity day has to be one day between the end date and the start date of the travel");
}
else
{
var values = new Dictionary <string, string>
{
{ "TravelId", Travel.id.ToString() },
{ "Description", NewActivityDescription },
{ "Start", NewActivityStart.TimeOfDay.ToString() }
};
var content = new FormUrlEncodedContent(values);
var result = await Client.HttpClient.PostAsync("http://localhost:65177/api/Travel/Activity", content);
if (result.StatusCode == HttpStatusCode.OK)
{
ActivitiesList.Add(System.Threading.Tasks.Task.Run(() => GetActivities()).Result.Last());
return("");
}
return("An error occurred when adding the activity to the itinerary");
}
}
internal async void RemoveActivityAsync(Activity activity)
{
var result = await Client.HttpClient.DeleteAsync("http://localhost:65177/api/Travel/" + Travel.id.ToString() + "/Activity/" + activity.Id);
if (result.StatusCode == System.Net.HttpStatusCode.OK)
{
ActivitiesList.Remove(activity);
}
}
public PartialViewResult List_Prief()
{
ActivitiesList ActivitiesModel = new ActivitiesList
{
Activities = repository.Activities.Take(7)
};
return(PartialView(ActivitiesModel));
}
public ActionResult List_Single(int ActivitiesID)
{
ActivitiesList ActivitiesModel = new ActivitiesList
{
Activities = repository.Activities.Where(n => n.ID == ActivitiesID)
};
return(PartialView(ActivitiesModel));
}
public bool ExecuteLearningTime()
{
try
{
var sourceMachine = Machines.Single(_ => _.Name == "APP1");
var sourceUser = Users.Single(_ => _.Name == "triservice");
// Generate Samr for domainController learning time
foreach (var domainController in DomainControllers)
{
ActivitiesList.Add(DocumentCreator.SamrCreator(sourceUser, sourceMachine,
domainController,
DomainList.Single(_ => _.Id == sourceUser.Domain).Name
, DomainList.Single(_ => _.Id == sourceMachine.Domain).Name, SourceGateway, true,
SamrQueryType.EnumerateUsers, SamrQueryOperation.EnumerateUsersInDomain,
DomainList.Single(_ => _.Id == sourceMachine.Domain).Id, 35));
}
InsertActivities(true);
do
{
SamrReconnaissanceDetectorProfile = GetSamrDetectorProfile();
} while (SamrReconnaissanceDetectorProfile["DestinationComputerIdToDetectionStartTimeMapping"]
.AsBsonArray.Count != DomainControllers.Count);
foreach (var coupledSamr in SamrCouples)
{
var samrAmount = coupledSamr.RatingType == "Low" ? 10 : 21;
for (var samrIndex = 0; samrIndex < samrAmount; samrIndex++)
{
var queriedObject = Users[_random.Next(Users.Count)];
ActivitiesList.Add(DocumentCreator.SamrCreator(coupledSamr.User, coupledSamr.Machine,
DomainControllers.First(_ => _.Domain == DomainList.Single(__ => __.Id == coupledSamr.Machine.Domain).Id),
DomainList.Single(_ => _.Id == coupledSamr.User.Domain).Name
, DomainList.Single(_ => _.Id == coupledSamr.Machine.Domain).Name, SourceGateway, true,
SamrQueryType.QueryUser, SamrQueryOperation.QueryInformationUser,
DomainList.Single(_ => _.Id == coupledSamr.Machine.Domain).Id, 10, queriedObject));
}
}
InsertActivities();
do
{
SamrReconnaissanceDetectorProfile = GetSamrDetectorProfile();
} while (SamrReconnaissanceDetectorProfile["DateToQueryToSamrQueryDataMapping"]
.AsBsonArray.Count == 0);
return(true);
}
catch (Exception e)
{
Logger.Debug(e);
return(false);
}
}
private void InsertActivities(bool isLearning = false)
{
DbClient.ClearTestCollections();
SvcCtrl.StopService("ATACenter");
if (isLearning)
{
DbClient.SetCenterProfileForReplay();
DbClient.SetDetectorProfileForSamr();
}
DbClient.InsertBatch(ActivitiesList);
ActivitiesList.Clear();
SvcCtrl.StartService("ATACenter");
}
private void ReloadActivities(List <Activity> activities)
{
ActivitiesList.Clear();
activities = activities.Select(c =>
{
c.Detail =
c.Detail == null ? null :
c.Detail.Length <= 500 ? c.Detail :
c.Detail.Substring(0, 495) + "..."; return(c);
}).ToList();
foreach (var activity in activities)
{
ActivitiesList.Add(activity.Cast <ActivityItemViewModel>());
}
}
public FetInputGenerator(DataModel model)
{
Model = model;
// Initialize list objects
DaysList = new DaysList(Model);
HoursList = new HoursList(Model);
TeachersList = new TeachersList(Model);
SubjectsList = new SubjectsList(Model);
ActivitiesList = new ActivitiesList(Model);
YearsList = new YearsList(Model);
TimeConstraintsList = new TimeConstraintsList(Model);
SpaceConstraintsList = new SpaceConstraintsList(Model);
RoomsList = new RoomsList(Model);
}
//
// GET: /Activities/
public ViewResult List_All(int page = 1)
{
ActivitiesList ActivitiesModel = new ActivitiesList
{
Activities = repository.Activities.Skip((page - 1) * PageSize).Take(PageSize),
PageInfo = new PageInfo
{
CurrentPage = page,
ItemsPerPage = PageSize,
TotalItems = repository.Activities.Count()
}
};
return(View(ActivitiesModel));
}
/// <summary>
/// Creates the array of XElements for the constraint.
/// </summary>
/// <returns>The created array.</returns>
/// <param name="dB">Datamodel.</param>
public override XElement[] Create(DataModel dB)
{
ActivitiesList activitiesList = new ActivitiesList(dB);
activitiesList.Create();
var query = from activity in activitiesList.Activities.Values
group new { id = activity.GroupId, activity.TotalDuration, activity.Duration }
by activity.GroupId into g
where g.Count() > 1
select g;
var result = new List <ConstraintMinDaysBetweenActivities>();
foreach (var item in query)
{
var firstElement = item.First();
result.Add(new ConstraintMinDaysBetweenActivities {
GroupID = firstElement.id, NumberOfActivities = (int)Math.Ceiling(firstElement.TotalDuration / (double)firstElement.Duration)
});
}
return(result.Select(item => item.ToXelement()).ToArray());
}
private void buttonRefresh_Click(object sender, EventArgs e)
{
dataGridView.Rows.Clear();
DisableFilterBox();
DisableButtons();
var nameFilter = GetFilter();
var from = dateTimePickerFrom.Value;
var until = dateTimePickerUntil.Value;
var task = Task <ActivitiesList> .Factory.StartNew(() => processor.Process(nameFilter, false, from, until));
try
{
activitiesTempStorage = task.Result;
}
catch (Exception)
{
MessageBox.Show("An error occured while processing collected data.");
}
if (activitiesTempStorage != null)
{
for (int i = 0; i < activitiesTempStorage.Count; i++)
{
DataGridViewRow row = ToDataGridViewRow(activitiesTempStorage[i]);
row.HeaderCell.Value = (i + 1).ToString();
dataGridView.Rows.Add(row);
}
}
else
{
MessageBox.Show("There's no activities");
}
EnableFilterBox();
EnableButtons();
}
/// <summary>
/// Select all activities from ActivitiesList
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void SelectAllItems_Click(object sender, RoutedEventArgs e)
{
ActivitiesList.SelectAll();
}
private void buttonTransmit_Click(object sender, EventArgs e)
{
System.Runtime.GCSettings.LatencyMode = GCLatencyMode.LowLatency;
if (activitiesTempStorage == null)
{
MessageBox.Show("There's nothing to transmit");
return;
}
DisableFilterBox();
DisableButtons();
var sync = SynchronizationContext.Current;
if (!this.sender.Authorized && e.GetType() != typeof(LoginPasswordEventArgs))
{
Task.Factory.StartNew(() =>
{
LoginWithForm(sync);
});
return;
}
string login = string.Empty, password = string.Empty;
if (!this.sender.Authorized)
{
login = (e as LoginPasswordEventArgs).Login;
password = (e as LoginPasswordEventArgs).Password;
if (login == string.Empty || password == string.Empty)
{
EnableButtons();
EnableFilterBox();
return;
}
}
Task authorizationTask = new Task(() =>
{
if (!this.sender.Authorized) // after first 'if' data was obtained as EventArgs
{
HttpStatusCode authorizationStatusCode;
bool success;
try
{
success = this.sender.Authorize(login, password, out authorizationStatusCode);
}
catch (WebException ex)
{
MessageBox.Show($"An error occured while authorization\n{ex.Message}");
return;
}
if (!success)
{
int authCode = (int)authorizationStatusCode;
MessageBox.Show($"Authorization failed. Code {authCode}: {authorizationStatusCode}");
EnableButtonsFromAnotherTask(sync);
EnableFilterBoxFromAnotherTask(sync);
}
}
});
authorizationTask.Start();
authorizationTask.Wait();
if (!this.sender.Authorized)
{
return;
}
Task <List <Report> > splittingActivitiesListTask = new Task <List <Report> >(() =>
{
List <Report> r = new List <Report>();
while (activitiesTempStorage.Count > 0)
{
var a = activitiesTempStorage.Take(activitiesToSendAtOneTime).ToList();
r.Add(new Report()
{
Activities = a
});
activitiesTempStorage.RemoveRange(0, a.Count);
}
return(r);
});
splittingActivitiesListTask.Start();
List <Report> reports = splittingActivitiesListTask.Result;
var tokenSource = new CancellationTokenSource();
var cancellation = tokenSource.Token;
SendingProgressForm sendingProgressForm = ShowProgressForm(sync, reports.Count, tokenSource);
Task sendingTask = new Task((token) =>
{
CancellationToken cancellationToken = (CancellationToken)token;
while (reports.Any())
{
cancellationToken.ThrowIfCancellationRequested();
var report = reports.First();
HttpStatusCode sendStatusCode;
string result;
try
{
result = this.sender.SendActivities(report, out sendStatusCode);
}
catch (Exception ex)
{
MessageBox.Show($"An error occured while sending activities\n{ex.Message}");
return;
}
int code = (int)sendStatusCode;
if (sendStatusCode == HttpStatusCode.Created)
{
reports.Remove(report);
IncrementProgress(sync, sendingProgressForm);
}
}
processor.MarkRegistriesAsProcessed(activitiesTempStorage.RegistriesIds);
},
cancellation, TaskCreationOptions.LongRunning);
Task continuation = sendingTask.ContinueWith((obj) =>
{
if (cancellation.IsCancellationRequested)
{
StopProgressOnCancel(sync, sendingProgressForm);
}
else
{
CompleteProgress(sync, sendingProgressForm);
}
activitiesTempStorage = null;
EnableFilterBoxFromAnotherTask(sync);
EnableButtonsFromAnotherTask(sync);
ClearDataFromAnotherTask(sync);
});
sendingTask.Start();
}
private void GetData()
{
ActivitiesList.DataSource = ar.Select();
ActivitiesList.DataBind();
}
public bool ExecuteSamrDetection()
{
try
{
var sensitiveGroupList = DbClient.GetSensitiveGroups();
foreach (var coupledSamr in SamrCouples)
{
var domainController = DomainControllers.First(_ =>
_.Domain == DomainList.Single(__ => __.Id == coupledSamr.Machine.Domain).Id);
if (coupledSamr.RatingType.ToLower() == "low")
{
var administratorObject = Users.First(_ => _.Name == "Administrator");
ActivitiesList.Add(DocumentCreator.KerberosCreator(coupledSamr.User, coupledSamr.Machine,
domainController, DomainList.Single(_ => _.Id == coupledSamr.User.Domain).Name
, DomainList.Single(_ => _.Id == coupledSamr.Machine.Domain).Name, SourceGateway));
ActivitiesList.Add(DocumentCreator.KerberosCreator(coupledSamr.User, coupledSamr.Machine,
domainController, DomainList.Single(_ => _.Id == coupledSamr.User.Domain).Name
, DomainList.Single(_ => _.Id == coupledSamr.Machine.Domain).Name, SourceGateway,
$"{(Spn) _random.Next(0, 5)}/{DomainControllers.FirstOrDefault()?.Name}", null, "Tgs", 0,
0, ActivitiesList.Last()["_id"].AsObjectId));
ActivitiesList.Add(DocumentCreator.KerberosCreator(coupledSamr.User, coupledSamr.Machine,
domainController, DomainList.Single(_ => _.Id == coupledSamr.User.Domain).Name
, DomainList.Single(_ => _.Id == coupledSamr.Machine.Domain).Name, SourceGateway,
$"{(Spn) _random.Next(0, 5)}/{DomainControllers.FirstOrDefault()?.Name}", null, "Ap", 0,
0, ActivitiesList.Last()["_id"].AsObjectId));
ActivitiesList.Add(DocumentCreator.SamrCreator(coupledSamr.User, coupledSamr.Machine,
domainController,
DomainList.Single(_ => _.Id == coupledSamr.User.Domain).Name
, DomainList.Single(_ => _.Id == coupledSamr.Machine.Domain).Name, SourceGateway, true,
SamrQueryType.QueryUser, SamrQueryOperation.QueryInformationUser,
DomainList.Single(_ => _.Id == coupledSamr.Machine.Domain).Id, 0,
administratorObject));
}
else
{
ActivitiesList.Add(DocumentCreator.KerberosCreator(coupledSamr.User, coupledSamr.Machine,
domainController, DomainList.Single(_ => _.Id == coupledSamr.User.Domain).Name
, DomainList.Single(_ => _.Id == coupledSamr.Machine.Domain).Name, SourceGateway));
ActivitiesList.Add(DocumentCreator.KerberosCreator(coupledSamr.User, coupledSamr.Machine,
domainController, DomainList.Single(_ => _.Id == coupledSamr.User.Domain).Name
, DomainList.Single(_ => _.Id == coupledSamr.Machine.Domain).Name, SourceGateway,
$"{(Spn)_random.Next(0, 5)}/{DomainControllers.FirstOrDefault()?.Name}", null, "Tgs", 0,
0, ActivitiesList.Last()["_id"].AsObjectId));
ActivitiesList.Add(DocumentCreator.KerberosCreator(coupledSamr.User, coupledSamr.Machine,
domainController, DomainList.Single(_ => _.Id == coupledSamr.User.Domain).Name
, DomainList.Single(_ => _.Id == coupledSamr.Machine.Domain).Name, SourceGateway,
$"{(Spn)_random.Next(0, 5)}/{DomainControllers.FirstOrDefault()?.Name}", null, "Ap", 0,
0, ActivitiesList.Last()["_id"].AsObjectId));
foreach (var group in sensitiveGroupList)
{
ActivitiesList.Add(DocumentCreator.SamrCreator(coupledSamr.User, coupledSamr.Machine,
domainController,
DomainList.Single(_ => _.Id == coupledSamr.User.Domain).Name
, DomainList.Single(_ => _.Id == coupledSamr.Machine.Domain).Name, SourceGateway, true,
SamrQueryType.QueryGroup, SamrQueryOperation.QueryInformationGroup,
DomainList.Single(_ => _.Id == coupledSamr.Machine.Domain).Id, 0,
group));
}
}
}
InsertActivities();
return(true);
}
catch (Exception e)
{
Logger.Debug(e);
return(false);
}
}
