static void Main(string[] args)
{
var model = new Collaboration()
{
ExpireDate = DateTime.Now.AddDays(10)
};
var test = JsonConvert.SerializeObject(model);
//var lurker = new ClipboardLurker();
using (var lurker = new ClientLurker())
{
lurker.WaitForPoe().Wait();
Console.WriteLine("Poe Found");
lurker.LocationChanged += Lurker_ChangedLocation;
lurker.RemainingMonsters += Watcher_RemainingMonsters;
lurker.PlayerJoined += Watcher_PlayerJoined;
lurker.PlayerLeft += Watcher_PlayerLeft;
lurker.Whispered += Watcher_Whispered;
lurker.IncomingOffer += Lurker_NewOffer;
Console.Read();
}
Console.WriteLine("Yeah");
Console.Read();
}
public static CollaborationDTO ToDTO(this Collaboration collaboration)
{
return(new CollaborationDTO {
UserId = collaboration.UserId,
BoardId = collaboration.BoardId
});
}
public async Task <IActionResult> Edit(int id, [Bind("ID,ColabboratorName,Institute,Compounds,Position,phdM2,Test,LabDayId")] Collaboration collaboration)
{
if (id != collaboration.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(collaboration);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CollaborationExists(collaboration.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["LabDayId"] = new SelectList(_context.Set <LabDay>(), "ID", "ID", collaboration.LabDayId);
return(View(collaboration));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Name,BrewSite,StyleId,CollaborationRequestId")] Collaboration collaboration)
{
if (id != collaboration.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
collaboration.Updated = DateTime.Now;
_context.Update(collaboration);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CollaborationExists(collaboration.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["StyleId"] = new SelectList(_context.BeerStyle, "Id", "Id", collaboration.StyleId);
ViewData["CollaborationRequestId"] = new SelectList(_context.CollaborationRequest, "Id", "Id", collaboration.CollaborationRequestId);
return(View(collaboration));
}
public void TestSetCollaboration()
{
var collaboration = new Collaboration(StatusesCollaboration.Active, 20);
var resultCollaboration = HotelService.SetCollaboration(1, collaboration, @"<a href=""http://previo.cz "">odkaz na previo bez cestiny</a>" + Moon.Web.HttpUtility.HtmlEncode("ěščřžýáíé", Moon.Web.EncodeOptions.FullEncode));
Assert.IsTrue(resultCollaboration.Status == StatusesCollaboration.WaitingForHotel && Math.Abs(collaboration.TotalBonusRate - 20) < 0.001);
}
public ActionResult DeleteConfirmed(int id)
{
Collaboration collaboration = db.Collaborations.Find(id);
db.Collaborations.Remove(collaboration);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void TestSerializaceObjektuCollaboration()
{
const string xmlToEquals =
"<collaboration><partnerBonusRate>0</partnerBonusRate><previoBonusRate>0</previoBonusRate><totalBonusRate>20.5</totalBonusRate><status>active</status></collaboration>";
var collaboration = new Collaboration(StatusesCollaboration.Active, 20.5);
var xml = collaboration.ToSnippetXmlOrNull();
Assert.IsTrue(xmlToEquals == xml);
}
public ContactViewModel(BackendService <UserT> backend, App app) : base(backend, app)
{
_contacts = new ObservableCollection <Contact>();
_editContact = new Contact();
_editContact.OwnedBy = app;
_invitations = new ObservableCollection <Invitation>();
_editInvitation = new Invitation();
_collaboration = new Collaboration();
_collaboration.OwnedBy = _editContact;
}
public ActionResult Edit([Bind(Include = "id_collaboration,id_track,id_collaboratortype,name,active,created_at,updated_at")] Collaboration collaboration)
{
if (ModelState.IsValid)
{
db.Entry(collaboration).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.id_collaboratortype = new SelectList(db.CollaboratorTypes, "id_collaboratortype", "name", collaboration.id_collaboratortype);
ViewBag.id_track = new SelectList(db.Tracks, "id_track", "name", collaboration.id_track);
return(View(collaboration));
}
public async Task <Collaboration> UpdateCollaborationAsync(Collaboration collaboration)
{
try
{
return(await _webApiClient.PutEntityAsync(collaboration));
}
catch (Exception ex)
{
_logger.WriteError(ex, LogCategories);
throw ex;
}
}
public ActionResult Edit([Bind(Include = "Id,ProjetId,CollaborateurId")] Collaboration collaboration)
{
if (ModelState.IsValid)
{
db.Entry(collaboration).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.CollaborateurId = new SelectList(db.Users, "Id", "Nom", collaboration.CollaborateurId);
ViewBag.ProjetId = new SelectList(db.Projets, "Id", "Nom", collaboration.ProjetId);
return(View(collaboration));
}
public async Task <IActionResult> Create([Bind("ID,ColabboratorName,Institute,Compounds,Position,phdM2,Test,LabDayId")] Collaboration collaboration)
{
if (ModelState.IsValid)
{
_context.Add(collaboration);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["LabDayId"] = new SelectList(_context.Set <LabDay>(), "ID", "ID", collaboration.LabDayId);
return(View(collaboration));
}
public ActionResult Create([Bind(Include = "Id,ProjetId,CollaborateurId")] Collaboration collaboration)
{
if (ModelState.IsValid)
{
db.Collaborations.Add(collaboration);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.CollaborateurId = new SelectList(db.Users, "Id", "Nom", collaboration.CollaborateurId);
ViewBag.ProjetId = new SelectList(db.Projets, "Id", "Nom", collaboration.ProjetId);
return(View(collaboration));
}
/// <summary>
/// Seeds database with a user with two tasks to start out with
/// </summary>
/// <param name="userManager"></param>
/// <param name="repository"></param>
public static async Task SeedUsers(UserManager <reactCrashUser> userManager, ITaskRepository repository, IAlertRepository alertRepository)
{
reactCrashUser reactCrashUserSeed = new reactCrashUser {
UserName = "******", Email = "*****@*****.**", EmailConfirmed = true
};
var isAdded = await SeedUser(userManager, reactCrashUserSeed);
if (isAdded == IdentityResult.Success)
{
reactCrashUser reactCrashUserSeedReversed = new reactCrashUser {
UserName = "******", Email = "*****@*****.**", EmailConfirmed = true
};
isAdded = await SeedUser(userManager, reactCrashUserSeedReversed);
try
{
Collaboration collab = new Collaboration();
collab.user = reactCrashUserSeedReversed;
comment sampleComment = new comment {
date = DateTime.Now, text = "Test", user = reactCrashUserSeed
};
List <comment> sampleComments = new List <comment>();
sampleComments.Add(sampleComment);
List <TaskEntity> taskEntities = new List <TaskEntity>
{
new TaskEntity {
details = "foo", location = "bar", text = "foobar", task_date = DateTime.Now, reminder = false, user = reactCrashUserSeed, is_completed = true, date_completed = DateTime.Now, comments = sampleComments
},
new TaskEntity {
details = "bar", location = "foo", text = "barfoo", task_date = DateTime.Now.AddDays(3), user = reactCrashUserSeed, reminder = true, is_completed = false
}
};
collab.task = taskEntities[0];
taskEntities[0].collaboratorations = new List <Collaboration>()
{
collab
};
var result = await repository.AddTasks(taskEntities);
alert a = new alert {
date = DateTime.Now, message = "Created", user = userManager.Users.FirstOrDefault(u => u.UserName == "*****@*****.**")
};
var alertResult = await alertRepository.CreateAlert(a);
}
catch (Exception e)
{
var message = e.Message;
}
}
}
public async Task <IActionResult> PutBoard(int id, BoardDTO boardDTO)
{
var board = await _context.Boards.Where(b => b.Id == id).FirstOrDefaultAsync();
if (id != boardDTO.Id)
{
return(BadRequest());
}
board.Name = boardDTO.Name;
// Partie pour vider les collaborations du board et de la DB
//des users qui ont été enlevés lors de l'edit
var collabsInDTO = boardDTO.Collaborations.Select(x => x);
foreach (var c in board.Collaborations)
{
if (!collabsInDTO.Contains(c.User.Id))
{
_context.Collaborations.Remove(c);
}
}
// Partie pour ajouter les collaborations au board
//si il ne les contient pas deja alors on les ajoute
if (boardDTO.Collaborations != null)
{
var collabs = board.Collaborations.Select(c => c.UserId);
foreach (var uid in boardDTO.Collaborations)
{
if (!collabs.Contains(uid))
{
var newCollab = new Collaboration {
UserId = uid
};
board.Collaborations.Add(newCollab);
}
}
}
var res = await _context.SaveChangesAsyncWithValidation();
if (!res.IsEmpty)
{
return(BadRequest(res));
}
return(NoContent());
}
public async Task TestMethod_Insert_NotThrows()
{
ICollaborationService service = _unityContainer.Resolve <ICollaborationService>();
IDataUnitOfWork unitOfWork = _unityContainer.Resolve <IDataUnitOfWork>();
Collaboration collaboration = CustomElements.CreateCollaborationModel();
collaboration = service.Create(collaboration);
await unitOfWork.SaveChangesAsync();
Collaboration collaborationSaved = service.Queryable().FirstOrDefault(f => f.EntityId == CustomElements.CollaborationId);
Assert.IsNotNull(collaborationSaved);
}
/// <summary>
/// Restituisce tutte le collaborazioni associate a un tavolo
/// </summary>
/// <param name="idDesk"></param>
/// <returns></returns>
public ICollection <Collaboration> GetCollaborationsByIdDesk(Guid idDesk)
{
Collaboration collaboration = null;
Desk desk = null;
ICollection <Collaboration> result = NHibernateSession.QueryOver <DeskCollaboration>()
.JoinAlias(x => x.Collaboration, () => collaboration)
.JoinAlias(x => x.Desk, () => desk)
.Where(() => desk.Id == idDesk)
.Select(s => s.Collaboration)
.List <Collaboration>();
return(result);
}
// GET: Collaboration/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Collaboration collaboration = db.Collaborations.Find(id);
if (collaboration == null)
{
return(HttpNotFound());
}
return(View(collaboration));
}
public Desk GetDeskByIdCollaboration(int idCollaboration)
{
Collaboration collaboration = null;
Desk desk = null;
Desk result = NHibernateSession.QueryOver <DeskCollaboration>()
.JoinAlias(x => x.Collaboration, () => collaboration)
.JoinAlias(x => x.Desk, () => desk)
.Where(() => collaboration.Id == idCollaboration)
.Select(s => s.Desk)
.SingleOrDefault <Desk>();
return(result);
}
public JsonResult DeleteCollaboration(int CalloborateID)
{
bool resul = false;
Collaboration sc = db.Collaborations.SingleOrDefault(x => x.CallobrationId == CalloborateID);
if (sc != null)
{
db.Collaborations.Remove(sc);
db.SaveChanges();
resul = true;
}
return(Json(resul, JsonRequestBehavior.AllowGet));
}
public bool IsDocumentJustInCollaboration(Guid idDesk, string docName)
{
CollaborationVersioning collaborationVersioning = null;
Collaboration collaboration = null;
bool result = NHibernateSession.QueryOver <DeskCollaboration>()
.JoinAlias(x => x.Collaboration, () => collaboration)
.JoinAlias(x => collaboration.CollaborationVersioning, () => collaborationVersioning)
.Where((x) => x.Desk.Id == idDesk && collaborationVersioning.DocumentName == docName)
.RowCount() > 0;
return(result);
}
public void AddDeskCollaboration(Desk desk, Collaboration collaboration)
{
if (desk == null || collaboration == null)
{
return;
}
DeskCollaboration deskCollaboration = new DeskCollaboration()
{
Desk = desk, Collaboration = collaboration
};
Save(ref deskCollaboration);
}
/// <summary>
/// Restituisce l'unica collaborazione associata al tavolo.
/// La collaborazione restituita sarà unica e non si troverà nello stato "Chiusa".
/// </summary>
/// <param name="idDesk"></param>
/// <returns></returns>
public Collaboration GetCollaborationByIdDesk(Guid idDesk)
{
Collaboration collaboration = null;
Desk desk = null;
Collaboration result = NHibernateSession.QueryOver <DeskCollaboration>()
.JoinAlias(x => x.Collaboration, () => collaboration)
.JoinAlias(x => x.Desk, () => desk)
.Where(() => desk.Id == idDesk)
.And(() => collaboration.IdStatus != CollaborationMainAction.AnnullataRitornoAlTavolo)
.Select(s => s.Collaboration)
.SingleOrDefault <Collaboration>();
return(result);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Before public void parseModel()
public virtual void parseModel()
{
modelInstance = Bpmn.readModelFromStream(this.GetType().getResourceAsStream(this.GetType().Name + ".xml"));
collaboration = modelInstance.getModelElementById(COLLABORATION_ID);
participant = modelInstance.getModelElementById(PARTICIPANT_ID + 1);
process = modelInstance.getModelElementById(PROCESS_ID + 1);
serviceTask = modelInstance.getModelElementById(SERVICE_TASK_ID);
exclusiveGateway = modelInstance.getModelElementById(EXCLUSIVE_GATEWAY);
startEvent = modelInstance.getModelElementById(START_EVENT_ID + 2);
sequenceFlow = modelInstance.getModelElementById(SEQUENCE_FLOW_ID + 3);
messageFlow = modelInstance.getModelElementById(MESSAGE_FLOW_ID);
dataInputAssociation = modelInstance.getModelElementById(DATA_INPUT_ASSOCIATION_ID);
association = modelInstance.getModelElementById(ASSOCIATION_ID);
endEvent = modelInstance.getModelElementById(END_EVENT_ID + 2);
}
public async Task <IActionResult> Create([Bind("ID,Title,Description,Bpm,SongKey,Genre,Type")] Collaboration collaboration)
{
if (ModelState.IsValid)
{
var applicationUser = await _userManager.GetUserAsync(User);
collaboration.Owner = applicationUser;
_context.Add(collaboration);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(collaboration));
}
public async Task DetailsTest()
{
var mockSvc = new Mock <ICollaborationService>();
var svcResult = new Collaboration();
mockSvc.Setup(s => s.GetDetailsAsync(TestProjectID)).ReturnsAsync(svcResult).Verifiable();
var ctrlr = GetTestController(mockSvc.Object);
var viewResult = await ctrlr.Details(TestProjectID);
Assert.True(ctrlr.IsInitialized);
mockSvc.VerifyAll();
Assert.True(viewResult is ViewResult);
Assert.True((viewResult as ViewResult).Model is CollaborationDetails);
Assert.Equal(svcResult, ((viewResult as ViewResult).Model as CollaborationDetails).Collab);
}
// GET: Collaboration/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Collaboration collaboration = db.Collaborations.Find(id);
if (collaboration == null)
{
return(HttpNotFound());
}
ViewBag.id_collaboratortype = new SelectList(db.CollaboratorTypes, "id_collaboratortype", "name", collaboration.id_collaboratortype);
ViewBag.id_track = new SelectList(db.Tracks, "id_track", "name", collaboration.id_track);
return(View(collaboration));
}
public ActionResult Accepter(int id)
{
Invitation invitation = db.Invitations.Find(id);
invitation.Etat = "Acceptée";
string id_ = Session["user"].ToString();
Collaboration collaboration = new Collaboration();
collaboration.CollaborateurId = id_;
collaboration.ProjetId = invitation.ProjetId;
db.Collaborations.Add(collaboration);
db.SaveChanges();
return(RedirectToAction("Index"));
}
// GET: Collaborations/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Collaboration collaboration = db.Collaborations.Find(id);
if (collaboration == null)
{
return(HttpNotFound());
}
ViewBag.CollaborateurId = new SelectList(db.Users, "Id", "Nom", collaboration.CollaborateurId);
ViewBag.ProjetId = new SelectList(db.Projets, "Id", "Nom", collaboration.ProjetId);
return(View(collaboration));
}
protected override UDSCollaboration BeforeUpdate(UDSCollaboration entity, UDSCollaboration entityTransformed)
{
if (entity.Repository != null)
{
entityTransformed.Repository = _unitOfWork.Repository <UDSRepository>().Find(entity.Repository.UniqueId);
}
if (entity.Relation != null)
{
Collaboration collaboration = _unitOfWork.Repository <Collaboration>().Find(entity.Relation.EntityId);
collaboration.IdStatus = "PT";
_unitOfWork.Repository <Collaboration>().Update(collaboration);
entity.Relation = collaboration;
CreateCollaborationRelationLog(entity);
}
return(base.BeforeUpdate(entity, entityTransformed));
}
public static Collaboration CreateCollaboration(global::System.Guid ID, global::System.Guid composition_Id, int index, string name, string notes)
{
Collaboration collaboration = new Collaboration();
collaboration.Id = ID;
collaboration.Composition_Id = composition_Id;
collaboration.Index = index;
collaboration.Name = name;
collaboration.Notes = notes;
return collaboration;
}
public void AddToCollaborations(Collaboration collaboration)
{
base.AddObject("Collaborations", collaboration);
}
