public IHttpActionResult Create([FromBody] ScrumMaster req)
{
var result = new List <Scrum>();
using (var ef = new ProjectMonitorDataContext())
{
var data = new ScrumMaster()
{
Total_Manhours = req.Total_Manhours,
Ended = req.Ended,
Ready_for_BA_Testing = req.Ready_for_BA_Testing,
UAT = req.UAT,
LIVE = req.LIVE,
Total_Manhours1 = req.Total_Manhours1,
Ended1 = req.Ended1,
Ready_for_BA_Testing1 = req.Ready_for_BA_Testing1,
UAT1 = req.UAT1,
LIVE1 = req.LIVE1,
Status = req.Status,
Completion = req.Completion,
Last_Update = req.Last_Update,
Progress_History = req.Progress_History,
Teams = req.Teams,
Conf_Type = req.Conf_Type,
Conf_Value = req.Conf_Value,
history = req.history,
Attachment = req.Attachment,
ITCM_SR_HPPID = req.ITCM_SR_HPPID,
};
ef.ScrumMasters.InsertOnSubmit(data);
ef.SubmitChanges();
}
return(Ok(result));
}
/// <summary>
/// Get general channel Id if scrum channel id does not exist.
/// </summary>
/// <param name="turnContext">Context object containing information cached for a single turn of conversation with a user.</param>
/// <param name="scrumMasterDetails">Scrum master details.</param>
/// <returns>Returns general channel Id if scrum channel id does not exist.</returns>
private async Task <string> GetValidChannelIdAsync(ITurnContext turnContext, ScrumMaster scrumMasterDetails)
{
var teamsChannelInfo = await TeamsInfo.GetTeamChannelsAsync(turnContext, scrumMasterDetails.TeamId, CancellationToken.None);
var channelInfo = teamsChannelInfo.Where(channel => channel.Id.Equals(scrumMasterDetails.ChannelId, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
if (channelInfo != null)
{
return(scrumMasterDetails.ChannelId);
}
scrumMasterDetails.ChannelId = scrumMasterDetails.TeamId;
scrumMasterDetails.ChannelName = Constants.GeneralChannel;
List <ScrumMaster> scrumMasters = new List <ScrumMaster>();
scrumMasters.Add(scrumMasterDetails);
var saveResponse = await this.scrumMasterStorageProvider.StoreOrUpdateScrumMasterEntitiesAsync(scrumMasters);
if (!saveResponse)
{
this.logger.LogError("Error while saving scrum master details.");
}
return(scrumMasterDetails.TeamId);
}
public void addTeamMemberTest()
{
// Arrange
Developer dev1 = new Developer();
Developer dev2 = new Developer();
Developer dev3 = new Developer();
ScrumMaster scrum = new ScrumMaster();
// Act
_sprint.addTeamMember(dev1);
_sprint.addTeamMember(dev2);
_sprint.addTeamMember(dev3);
_sprint.addTeamMember(scrum);
_sprint.removeTeamMember(dev2);
_backlogItem1.assign(dev1);
_backlogItem1.backlogState.doing();
_backlogItem1.backlogState.done();
_sprint.backlog.updateBacklogItem(_backlogItem1);
// Assert
Assert.IsTrue(_sprint.getTeam().Count == 3);
Assert.IsTrue(
_sprint.getTeam().ContainsKey(dev1) &&
_sprint.getTeam().ContainsKey(dev3) &&
_sprint.getTeam().ContainsKey(scrum)
);
}
private void CreateUserBlankByRole(User user, RoleType role, Specialization specialization)
{
switch (role)
{
case RoleType.Mentor:
if (!_context.Mentors.Any(m => m.Id == user.Id))
{
_context.Mentors.Add(Mentor.GetBlank(user, specialization));
}
break;
case RoleType.ScrumMaster:
if (!_context.ScrumMasters.Any(sm => sm.Id == user.Id))
{
_context.ScrumMasters.Add(ScrumMaster.GetBlank(user));
}
break;
case RoleType.Trainee:
if (!_context.Trainees.Any(t => t.Id == user.Id))
{
_context.Trainees.Add(Trainee.GetBlank(user, specialization));
}
break;
case RoleType.HR:
return;
default:
throw new Exception("Invalid RoleType");
}
}
public IHttpActionResult Update([FromBody] ScrumMaster req)
{
try
{
if (req != null)
{
using (var team = new ProjectMonitorDataContext())
{
var gf = team.ScrumMasters.FirstOrDefault(b => b.Total_Manhours == req.Total_Manhours);
{
gf.Teams = req.Teams;
}
team.SubmitChanges();
return(Ok(gf));
}
}
else
{
return(Unauthorized());
}
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
/// <summary>
/// Set the timer and enqueue start scrum task if timer matched as per CRON expression.
/// </summary>
/// <returns>A task that schedules scrum of next hour.</returns>
/// <remark>Scrum schedules for next hour. For example at 9 am it schedules all scrum of 10 and 10:30 am.</remark>
private Task ScheduleScrumAsync(CronExpression expression, ScrumMaster scrumMaster)
{
var count = Interlocked.Increment(ref this.executionCount);
this.logger.LogInformation($"Scheduling scrum task is working. Count: {count}");
// Get the timezone entered by the user to schedule scrum on user specified time.
TimeZoneInfo timeZoneInfo = TimeZoneInfo.FindSystemTimeZoneById(scrumMaster.TimeZone);
var next = expression.GetNextOccurrence(DateTimeOffset.Now, timeZoneInfo);
if (next.HasValue)
{
var delay = next.Value - DateTimeOffset.Now;
this.scrumTimer = new System.Timers.Timer(delay.TotalMilliseconds);
this.scrumTimer.Elapsed += (sender, args) =>
{
this.logger.LogInformation($"Timer matched to send notification at timer value : {this.scrumTimer}");
this.scrumTimer.Stop(); // reset timer
this.StartScrumAsync(scrumMaster);
};
this.scrumTimer.AutoReset = false;
this.scrumTimer.Start();
}
return(Task.CompletedTask);
}
public ScrumTraineesViewModel ReviewToEditViewModel(ScrumMaster scrumMaster, List <Review> reviews)
{
return(new ScrumTraineesViewModel
{
ScrumMasterId = scrumMaster.Id,
Reviews = reviews.Select(_mapper.Map <Review, ScrumReviewEditViewModel>).ToList()
});
}
public void Constructor_NameIsEmpty_ArgumentNullException()
{
// Arrange
var team = new ScrumTeam("test team");
// Act
var result = new ScrumMaster(team, string.Empty);
}
public void Constructor_TeamNotSpecified_ArgumentNullException()
{
// Arrange
var name = "test";
// Act
var result = new ScrumMaster(null, name);
}
public BacklogStateTest()
{
var scrumMaster = new ScrumMaster();
var sprint = new Sprint("Sprint 1", new DateTime(), new DateTime().AddDays(7), scrumMaster);
_backlogItem1 = new BacklogItem(sprint.backlog, "mn leuke item", 18);
sprint.backlog.addBacklogItem(_backlogItem1);
}
public ScrumMasterDTO GetById(int Id)
{
ScrumMasterDTO retour = new ScrumMasterDTO();
ScrumMaster objet = _repo.Get(Id);
retour = MapScrumMasterDTO.ToDto(objet);
return(retour);
}
public ScrumMasterDTO Update(ScrumMasterDTO objet)
{
ScrumMaster entity = MapScrumMaster.ToEntity(objet, false);
ScrumMaster resultat = _repo.Update(entity);
ScrumMasterDTO retour = MapScrumMasterDTO.ToDto(resultat);
return(retour);
}
public ScrumMasterDTO Create(ScrumMasterDTO objet)
{
ScrumMaster entite = MapScrumMaster.ToEntity(objet, true);
ScrumMaster resultat = _repo.Create(entite);
objet = MapScrumMasterDTO.ToDto(resultat);
return(objet);
}
/// <summary>
/// Method ends the existing scrum if running and then sends the start scrum card.
/// </summary>
/// <param name="scrumMaster">Scrum master details obtained from storage.</param>
/// <returns>A task that ends the existing scrum and sends the start scrum card .</returns>
public async Task ScrumStartActivityAsync(ScrumMaster scrumMaster)
{
if (scrumMaster != null)
{
try
{
string serviceUrl = scrumMaster.ServiceUrl;
MicrosoftAppCredentials.TrustServiceUrl(serviceUrl);
var conversationReference = new ConversationReference()
{
ChannelId = Constants.ConversationChannelId,
Bot = new ChannelAccount()
{
Id = this.microsoftAppCredentials.MicrosoftAppId
},
ServiceUrl = serviceUrl,
Conversation = new ConversationAccount()
{
ConversationType = Constants.ConversationType, IsGroup = true, Id = scrumMaster.ChannelId, TenantId = this.options.Value.TenantId
},
};
this.logger.LogInformation($"Sending start scrum command to channelId- {scrumMaster.ChannelId}");
await RetryPolicy.ExecuteAsync(async() =>
{
try
{
await((BotFrameworkAdapter)this.adapter).ContinueConversationAsync(
this.microsoftAppCredentials.MicrosoftAppId,
conversationReference,
async(conversationTurnContext, conversationCancellationToken) =>
{
bool isValidScrum = await this.EndExistingScrumAndStartScrumAsync(conversationTurnContext, scrumMaster, conversationCancellationToken);
if (!isValidScrum)
{
this.logger.LogInformation("Error while ending the existing scrum.");
await conversationTurnContext.SendActivityAsync(this.localizer.GetString(this.localizer.GetString("ErrorMessage")));
}
await this.SendScrumStartCardAsync(conversationTurnContext, scrumMaster, conversationCancellationToken);
},
CancellationToken.None);
}
catch (Exception ex)
{
this.logger.LogError(ex, "Error while performing retry logic to send scrum start card.");
throw;
}
});
}
catch (Exception ex)
{
this.logger.LogError(ex, "Error while sending start scrum to channel from background service.");
}
}
}
/// <summary>
/// Method that sends the start scrum card to the channel.
/// </summary>
/// <param name="turnContext">Context object containing information cached for a single turn of conversation with a user.</param>
/// <param name="scrumMaster">Scrum master details obtained from storage.</param>
/// <param name="cancellationToken">Propagates notification that operations should be canceled.</param>
/// <returns>A task that sends the start scrum card.</returns>
private async Task SendScrumStartCardAsync(ITurnContext turnContext, ScrumMaster scrumMaster, CancellationToken cancellationToken)
{
try
{
string scrumMasterId = scrumMaster.ScrumMasterId;
if (scrumMasterId != null)
{
this.logger.LogInformation($"Scrum start for ID: {scrumMasterId}");
var scrumSummary = await this.scrumHelper.GetScrumSummaryAsync(scrumMasterId);
if (scrumSummary == null)
{
this.logger.LogInformation($"Scrum master details are deleted from storage.");
await turnContext.SendActivityAsync(string.Format(CultureInfo.CurrentCulture, this.localizer.GetString("ErrorScrumDeleted"), scrumMaster.TeamName), cancellationToken : cancellationToken);
return;
}
// scrumSummary.ScrumStartTime = scrumMaster.StartTime;
var scrumStartActivityId = Guid.NewGuid().ToString();
// Fetching the members list based on the teams id:
turnContext.Activity.Conversation.Id = scrumMaster.TeamId;
var membersActivityIdMap = await this.GetActivityIdOfMembersInScrumAsync(turnContext, scrumMaster, cancellationToken);
string membersList = JsonConvert.SerializeObject(membersActivityIdMap);
// Mentioning the participants involved in the scrum
var mentionActivity = await this.GetMentionsActivityAsync(turnContext, scrumMaster, cancellationToken);
// Check if channel exists. If channel doesn't exist then scrum card will be sent in General channel.
scrumMaster.ChannelId = await this.GetValidChannelIdAsync(turnContext, scrumMaster);
// Send the start scrum card
turnContext.Activity.Conversation.Id = scrumMaster.ChannelId;
var attachment = ScrumCard.GetScrumStartCard(scrumSummary, membersActivityIdMap, scrumMasterId, scrumStartActivityId, this.localizer, scrumMaster.TimeZone);
var scrumStartActivity = MessageFactory.Attachment(attachment);
var scrumStartActivityResponse = await turnContext.SendActivityAsync(scrumStartActivity, cancellationToken);
// Update the conversation id to send mentioned participants as reply to scrum start card.
turnContext.Activity.Conversation = new ConversationAccount
{
Id = $"{scrumMaster.ChannelId};messageid={scrumStartActivityResponse.Id}",
};
await turnContext.SendActivityAsync(mentionActivity, cancellationToken);
await this.CreateScrumAsync(scrumStartActivityResponse.Id, scrumStartActivityId, membersList, scrumMaster, turnContext, cancellationToken);
this.logger.LogInformation($"Scrum start details saved to table storage for: {turnContext.Activity.Conversation.Id}");
}
}
catch (Exception ex)
{
this.logger.LogError(ex, $"Start scrum failed for {turnContext.Activity.Conversation.Id}: {ex.Message}", SeverityLevel.Error);
throw;
}
}
public SprintTest()
{
var scrumMaster = new ScrumMaster();
_sprint = new Sprint("Sprint 1", new DateTime(), new DateTime().AddDays(7), scrumMaster);
_backlogItem1 = new BacklogItem(_sprint.backlog, "mn leuke item", 18);
scrumMaster.addSprint(_sprint);
_sprint.sprintState.start();
_sprint.backlog.addBacklogItem(_backlogItem1);
}
public Sprint(string name, DateTime startTime, DateTime endTime, ScrumMaster scrumMaster)
{
backlog = new Backlog();
this.scrumMaster = scrumMaster;
this.name = name;
this.startTime = startTime;
this.endTime = endTime;
this.sprintState = new InitializedSprintState();
sprintState.setSprint(this);
team = new Dictionary <User, int>();
}
public void Constructor_SessionId_ZeroGuid()
{
// Arrange
var team = new ScrumTeam("test team");
var name = "test";
// Act
var result = new ScrumMaster(team, name);
// Verify
Assert.AreEqual <Guid>(Guid.Empty, result.SessionId);
}
public ForumTest()
{
Backlog backlog = new Backlog();
Developer dev = new Developer();
ScrumMaster scrumMaster = new ScrumMaster();
Sprint sprint = new Sprint("Sprint 1", new DateTime(), new DateTime().AddDays(7), scrumMaster);
sprint.addTeamMember(dev);
Forum forum = new Forum(sprint);
_backlogItem = new BacklogItem(backlog, "a new item", 12);
_thread = forum.addThread(_backlogItem, "there is a issue", "description", dev);
}
public void Constructor_TeamAndNameIsSpecified_TeamAndNameIsSet()
{
// Arrange
var team = new ScrumTeam("test team");
var name = "test";
// Act
var result = new ScrumMaster(team, name);
// Verify
Assert.AreEqual <ScrumTeam>(team, result.Team);
Assert.AreEqual <string>(name, result.Name);
}
public void AddSprintToScrumBoard()
{
//Arrange
ScrumBoard board = new ScrumBoard();
ScrumMaster master = new ScrumMaster();
Sprint sprint = new Sprint("sprint 1", DateTime.Now, DateTime.Now.AddDays(14), master);
//Act
project.AddBoard(board);
project.AddSprint(sprint);
//Assert
Assert.IsTrue(project.GetBoard().getSprints().Count >= 1);
}
private void AddScrumMasters(ProfileContext context)
{
int smCount = context.Groups.Count(g => g.Project.Status != ProjectStatus.Created);
var scrumNames = new List <string>
{
"Фролов Федр",
"Хрусталев Дмитрий",
"Баканов Алексей",
"Семенов Алексей",
"Грядов Петр"
};
for (int i = 1; i <= smCount; i++)
{
var user = new User
{
Login = $"ScrumLogin{i}",
Email = $"email_{i}@mail.com",
FullName = i <= scrumNames.Count ?
scrumNames[i - 1] :
"Scrum FullName"
};
user.Contacts = new Contacts
{
Email = $"email_{i}@gmail.com",
Skype = $"Skype-{i}",
Phone = $"000-{i}",
LinkedIn = $"LinkedIn-{i}"
};
_userManager.CreateAsync(user, $"Password{i}").Wait();
var scrum = new ScrumMaster {
User = user
};
context.ScrumMasters.Add(scrum);
}
context.SaveChanges();
foreach (var scrum in context.ScrumMasters.ToList())
{
_userManager.AddToRoleAsync(scrum.Id, RoleType.ScrumMaster).Wait();
}
}
internal static ScrumMasterDTO ToDto(ScrumMaster objet)
{
ScrumMasterDTO retour = new ScrumMasterDTO();
if (objet != null)
{
retour.Id = objet.Id;
retour.LastName = objet.LastName;
retour.FirstName = objet.FirstName;
retour.FullName = objet.FirstName + " " + objet.LastName;
retour.IsDeleted = objet.IsDeleted;
retour.DateCreation = (System.DateTime)objet.DateCreation;
retour.DateModification = (System.DateTime)objet.DateModification;
}
return(retour);
}
public bool CreateScrumMaster(ScrumMasterCreate model)
{
var entity =
new ScrumMaster()
{
OwnerId = _userId,
FirstName = model.FirstName,
LastName = model.LastName
};
using (var ctx = new ApplicationDbContext())
{
ctx.ScrumMasters.Add(entity);
return(ctx.SaveChanges() == 1);
}
}
internal static void Bridge()
{
Console.WriteLine("Bridge Pattern Demo");
Console.WriteLine("----------------------------");
ReaderApp appWindows7 = new Windows7(new NormalDisplay())
{
Text = "This is a demo of Bridge"
};
appWindows7.Display();
ReaderApp appWindows10 = new Windows10(new NormalDisplay())
{
Text = "This is a demo of Bridge"
};
appWindows10.Display();
Console.WriteLine("");
ReaderApp appWindows7Reverse = new Windows7(new ReverseDisplay())
{
Text = "This is a demo of Bridge"
};
appWindows7Reverse.Display();
ReaderApp appWindows10Reverse = new Windows10(new ReverseDisplay())
{
Text = "This is a demo of Bridge"
};
appWindows10Reverse.Display();
Console.WriteLine(""); Console.WriteLine("");
Console.WriteLine("Bridge Pattern Demo 2");
Console.WriteLine("----------------------------");
Employee developer = new Developer(new Email());
Console.WriteLine(developer.ToString());
Employee scrumMaster = new ScrumMaster(new PhoneCall());
Console.WriteLine(scrumMaster.ToString());
}
public bool Delete(int Id)
{
bool resultat = false;
try
{
ScrumMaster entite = _context.ScrumMaster.Where(x => x.Id == Id).First();
entite.IsDeleted = true;
entite.DateModification = DateTime.UtcNow;
_context.Update(entite);
_context.SaveChanges();
resultat = true;
}
catch (Exception ex)
{
}
return(resultat);
}
public void AddBacklogItemToSprintTest()
{
//Arrange
ScrumBoard board = new ScrumBoard();
ScrumMaster master = new ScrumMaster();
Sprint sprint = new Sprint("sprint 1", DateTime.Now, DateTime.Now.AddDays(14), master);
Backlog backlog = new Backlog();
BacklogItem backlogitem = new BacklogItem(backlog, "test", 8);
//Act
project.AddBoard(board);
board.AddSprint(sprint);
board.AddBacklogItem(backlogitem);
//Assert
Assert.IsNotNull(project.GetBoard().getSprints());
Assert.IsTrue(sprint.backlog.backlogItems.Contains(backlogitem));
}
private void AddEmptyScrums(ProfileContext context)
{
var scrumNames = new List <string> {
"Будко Алена", "Даратон Сергей"
};
for (int i = 1; i <= scrumNames.Count; i++)
{
var user = new User
{
Login = $"ScrumEmptyLogin{i}",
Email = $"email_{i}@mail.com",
FullName = scrumNames[i - 1]
};
user.Contacts = new Contacts
{
Email = $"email_{i}@gmail.com",
Skype = $"Skype-{i}",
Phone = $"000-{i}",
LinkedIn = $"LinkedIn-{i}"
};
_userManager.CreateAsync(user, $"PasswordEmpty{i}").Wait();
var scrum = new ScrumMaster {
User = user
};
context.ScrumMasters.Add(scrum);
}
context.SaveChanges();
foreach (var scrum in context.ScrumMasters.ToList())
{
_userManager.AddToRoleAsync(scrum.Id, RoleType.ScrumMaster).Wait();
}
}
internal static ScrumMaster ToEntity(ScrumMasterDTO objet, bool creation)
{
ScrumMaster retour = new ScrumMaster();
if (objet != null)
{
retour.LastName = objet.LastName;
retour.FirstName = objet.FirstName;
if (creation)
{
retour.IsDeleted = false;
retour.DateCreation = DateTime.UtcNow;
retour.DateModification = objet.DateCreation;
}
else
{
retour.Id = objet.Id;
retour.IsDeleted = objet.IsDeleted;
retour.DateCreation = objet.DateCreation;
retour.DateModification = DateTime.UtcNow;
}
}
return(retour);
}
public UserTest()
{
_productOwner = new ProductOwner();
_scrumMaster = new ScrumMaster();
_project = new Project(_productOwner, "big project", "this is our biggest project yet");
}
