//================================================================================
public List <vmMusicianResult> GetMusicianCitiesByInstrument(vmMusicianSearch vmMS)
{
List <vmMusicianResult> vmMRs = new List <vmMusicianResult>();
Instrument i = _repo.Query <Instrument>().Where(n => n.InstrumentName == vmMS.PrimeInstrument).FirstOrDefault();
if (i == null)
{
return(null);
}
else
{
List <MusicianInstrument> mis = _repo.Query <MusicianInstrument>().Where(q => q.InstrumentId == i.InstrumentId && q.IsPrimary == true).ToList();
foreach (MusicianInstrument mitemp in mis)
{
Musician mus = _repo.Query <Musician>().Where(r => r.MusicianId == mitemp.MusicianId).FirstOrDefault();
UserMusician um = _repo.Query <UserMusician>().Where(s => s.MusicianId == mus.MusicianId).FirstOrDefault();
AppUser au = _repo.Query <AppUser>().Where(t => t.AppUserId == um.AppUserId).FirstOrDefault();
vmMusicianResult vmMRtemp = new vmMusicianResult
{
AppUserId = au.AppUserId,
FirstName = au.FirstName,
LastName = au.LastName,
City = au.City,
PrimeInstrument = i.InstrumentName
};
vmMRs.Add(vmMRtemp);
}
return(vmMRs);
}
}
/// <summary>
/// Adds a musician to a band
/// </summary>
/// <param name="Band"></param>
/// <param name="Musician"></param>
/// <returns></returns>
public static Band AddMusicianToBand(Band Band, Musician Musician)
{
using (var context = new BandBookerContext())
{
var dbBand =
(from x in context.Band
where x.BandId == Band.BandId
select x).FirstOrDefault();
var currentBM =
(from x in context.BandMusician
where x.BandId == Band.BandId &&
x.MusicianId == Musician.MusicianId
select x).FirstOrDefault();
if (currentBM == null)
{
var dbMusician =
(from x in context.Musician
where x.MusicianId == Musician.MusicianId
select x).FirstOrDefault();
var bm = new BandMusician()
{
Band = dbBand,
Musician = dbMusician
};
dbBand.BandMusician.Add(bm);
context.SaveChanges();
}
var thisband = (from x in Bands
where x.BandId == Band.BandId
select x).FirstOrDefault();
return(thisband);
}
}
/// <summary>
/// Gets a list of bookings that a musician has not responed to
/// </summary>
/// <param name="Musician"></param>
/// <returns></returns>
public static List <Booking> GetBookingsMusicianNeedsToRespondTo(
Musician Musician)
{
var bookings = GetAllBookingsByMusician(Musician);
var list = new List <Booking>();
foreach (var booking in bookings)
{
var responses =
from x in booking.BookingMusicianInstrument
where x.MusicianId == Musician.MusicianId &&
x.ResponseDate != null
select x;
if (responses.Count() == 0)
{
if (!list.Contains(booking))
{
var instruments =
GetInstrumentsByBookingAndMusician(booking, Musician);
if (instruments.Count > 0)
{
list.Add(booking);
}
}
}
}
return(list.ToList <Booking>());
}
public void OpenPanel(Musician musician, BandMemberUI bandMemberUI)
{
this.gameObject.SetActive(true);
for (int i = 0; i < _moveActionButtons.Length; i++)
{
Button button = _moveActionButtons[i];
if (i >= musician.GetMusicActions().Count)
{
button.gameObject.SetActive(false);
break;
}
button.gameObject.SetActive(true);
MusicAction musicAction = musician.GetMusicActions()[i];
button.onClick.RemoveAllListeners();
button.onClick.AddListener(() => moveBegin(musician, musicAction, bandMemberUI));
Text buttonText = button.transform.Find("Text").GetComponent <Text>();
buttonText.text = $"{musicAction.Name} ({musicAction.RoundsToCooldown})";
_musicianName.text = musician.Name + "'s moves:";
}
}
private void Validate(Musician musician, bool update = false)
{
if (string.IsNullOrEmpty(musician.name))
{
throw ValidateException("Insira o seu nome");
}
if (musician.name.Length > 100)
{
throw ValidateException("O tamanho máximo do nome é 100 caracteres");
}
if (string.IsNullOrEmpty(musician.email))
{
throw ValidateException("Insira o seu email");
}
if (string.IsNullOrEmpty(musician.password))
{
throw ValidateException("Insira sua senha");
}
if (!update)
{
VerifyIfEmailExists(musician.email);
}
if (musician.password.Length > 40)
{
throw ValidateException("O tamanho máximo da senha é 40 caracteres");
}
}
public IHttpActionResult Index(LoginModel model)
{
try
{
MusicianBusiness musicianBusiness = new MusicianBusiness();
Musician user = musicianBusiness.Login(model.email, model.password);
if (user == null)
{
return(Unauthorized());
}
BearerToken bearerLogin = new BearerToken(new BearerDatabaseManager(model.email));
bearerLogin.GenerateHeaderToken(user.id.ToString(), user.email);
return(Ok(user));
}
catch (Exception ex)
{
return(BadRequest(ex.StackTrace));
return(InternalServerError(ex));
}
}
public async Task <IActionResult> Create([Bind("ID,FirstName,MiddleName,LastName,Phone,DOB,SIN,InstrumentID")] Musician musician)
{
try
{
if (ModelState.IsValid)
{
_context.Add(musician);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
catch (DbUpdateException dex)
{
if (dex.InnerException.Message.Contains("IX_Musicians_SIN"))
{
ModelState.AddModelError("", "Unable to save changes. Remember, you cannot have duplicate SIN numbers.");
}
else
{
ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists see your system administrator.");
}
}
PopulateDropDownLists(musician);
return(View(musician));
}
public async Task <ActionResult <Musician> > PostMusician(Musician musician)
{
_context.Musicians.Add(musician);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetMusician", new { id = musician.Id }, musician));
}
public async Task <IActionResult> PutMusician(string id, Musician musician)
{
if (id != musician.Id)
{
return(BadRequest());
}
_context.Entry(musician).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MusicianExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void AddMusicianProfileToMusicianTest()
{
string timeMusician = "Test_" + DateTime.Now.ToString();
Musician musician = new Musician {
FirstName = timeMusician
};
_musicians.Create(musician);
Assert.AreEqual(musician.FirstName, _musicians.FindById(musician.MusicianId).FirstName);
string timeProfile = "Test_" + DateTime.Now.ToString();
MusicianProfile profile = new MusicianProfile {
Specialization = timeProfile, Musician = musician
};
_musicianProfiles.Create(profile);
Assert.AreEqual(profile.Specialization, _musicianProfiles.FindById(profile.MusicianId).Specialization);
Assert.IsNotNull(_musicians.FindById(profile.MusicianId));
_musicians.Delete(musician);
_musicianProfiles.Delete(profile);
Assert.IsTrue(_musicianProfiles.Get(x => x.Specialization == timeProfile).FirstOrDefault().IsDeleted);
}
public async Task <IActionResult> Edit(int id, [Bind("ID,FirstName,MiddleName,LastName,Phone,DOB,SIN,InstrumentID")] Musician musician)
{
if (MusicianSinExists(musician.SIN, musician.ID))
{
ModelState.AddModelError("", "Unable to save changes. SIN must be unique.");
ViewData["InstrumentID"] = new SelectList(_context.Instruments, "ID", "Name", musician.InstrumentID);
return(View(musician));
}
if (id != musician.ID)
{
return(NotFound());
}
Musician musicianToUpdate = await _context.Musicians.SingleOrDefaultAsync(s => s.ID == id);
if (await TryUpdateModelAsync <Musician>(musicianToUpdate, "", m => m.FirstName, m => m.MiddleName, m => m.LastName, m => m.Phone, m => m.DOB, m => m.SIN, m => m.InstrumentID))
{
try
{
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
catch (DbUpdateException)
{
ModelState.AddModelError("", "Unable to save changes. " +
"Try again, and if the problem persists, " +
"see your system administrator.");
}
}
ViewData["InstrumentID"] = new SelectList(_context.Instruments.OrderBy(x => x.Name), "ID", "Name", musician.InstrumentID);
return(View(musician));
}
public void StopPlaying(Musician musician)
{
if (OnMusicianStopPlaying != null)
{
OnMusicianStopPlaying.Invoke(musician);
}
}
public IActionResult CreateMusiacian(CreateMusicianDTORequest request)
{
Track track;
if (!_context.Tracks.Any(t => t.TrackName == request.TrackDTO.TrackName))
{
track = new Track
{
TrackName = request.TrackDTO.TrackName,
Duration = request.TrackDTO.duration
};
}
else
{
track = _context.Tracks.Where(t => t.TrackName == request.TrackDTO.TrackName && t.Duration == request.TrackDTO.duration).First();
}
var musician = new Musician
{
FirstName = request.FirstName,
LastName = request.LastName,
Nickname = request.NickName
};
var musicianTrack = new Musician_Track
{
Musician = musician,
Track = track
};
return(Created(Uri.EscapeDataString(""), musician));
}
//================================================================================
public List <vmMusicianResult> GetMusiciansByFirstLastNames(vmMusicianSearch vmMS)
{
List <vmMusicianResult> vmMRs = new List <vmMusicianResult>();
List <AppUser> aus = _repo.Query <AppUser>().Where(b => b.LastName == vmMS.LastName &&
b.FirstName == vmMS.FirstName).ToList();
if (aus == null)
{
return(null);
}
else
{
foreach (AppUser au in aus)
{
UserMusician um = _repo.Query <UserMusician>().Where(c => c.AppUserId == au.AppUserId).FirstOrDefault();
if (um != null)
{
Musician m = _repo.Query <Musician>().Where(d => d.MusicianId == um.MusicianId).FirstOrDefault();
MusicianInstrument mi = _repo.Query <MusicianInstrument>().Where(e => e.MusicianId == m.MusicianId && e.IsPrimary == true).FirstOrDefault();
Instrument i = _repo.Query <Instrument>().Where(f => f.InstrumentId == mi.InstrumentId).FirstOrDefault();
vmMusicianResult vmMRtemp = new vmMusicianResult
{
AppUserId = au.AppUserId,
FirstName = au.FirstName,
LastName = au.LastName,
City = au.City,
PrimeInstrument = i.InstrumentName
};
vmMRs.Add(vmMRtemp);
}
}
return(vmMRs);
}
}
public async Task <IActionResult> Register(RegisterViewModel vm)
{
if (ModelState.IsValid)
{
Musician user = new Musician
{
UserName = vm.FirstName + vm.LastName,
FirstName = vm.FirstName,
LastName = vm.LastName,
Email = vm.Email
};
IdentityResult result = await userManager.CreateAsync(user, vm.Password);
if (result.Succeeded)
{
await userManager.AddToRoleAsync(user, "Member");
if (result.Succeeded)
{
return(RedirectToAction("Index", "Home"));
}
}
else
{
foreach (IdentityError error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
}
return(View(vm));
}
public async Task <IActionResult> Edit(int id, [Bind("ApplicationUserId,Id,FirstName,LastName,Instrument,LookingForBand,WantToCollaborate,Influence1,Influence2,Influence3")] Musician musician)
{
if (id != musician.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
var userId = this.User.FindFirstValue(ClaimTypes.NameIdentifier);
musician.ApplicationUserId = userId;
_context.Update(musician);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MusicianExists(musician.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(musician));
}
public void StartGame()
{
if (string.IsNullOrEmpty(_musoNameInput.text) || string.IsNullOrEmpty(_bandNameInput.text))
{
Debug.LogWarning("Add names!");
return;
}
Instrument instrument = new Instrument(InstrumentType.Guitar);
switch (_instrumentDropdown.options[_instrumentDropdown.value].text)
{
case "Guitar":
instrument = new Instrument(InstrumentType.Guitar);
break;
case "Piano":
instrument = new Instrument(InstrumentType.Piano);
break;
case "Drum":
instrument = new Instrument(InstrumentType.Drum);
break;
case "Bass":
instrument = new Instrument(InstrumentType.Bass);
break;
}
Musician musician = new Musician(_musoNameInput.text, instrument, _musicianPortrait.sprite);
_gameController.AddMusician(musician);
_gameController.bandName = _bandNameInput.text;
_gameController.LoadScene("Map");
}
public async Task <MusicianResponse> UpdateAsync(int id, Musician performer)
{
var existingPerformer = await _musicianRepository.FindById(id);
if (existingPerformer == null)
{
return(new MusicianResponse("Musician not found"));
}
existingPerformer.FirstName = performer.FirstName;
existingPerformer.LastName = performer.LastName;
existingPerformer.Phone = performer.Phone;
existingPerformer.PersonalWeb = performer.PersonalWeb;
existingPerformer.BirthDate = performer.BirthDate;
existingPerformer.Description = performer.Description;
existingPerformer.Rating = performer.Rating;
try
{
_musicianRepository.Update(existingPerformer);
await _unitOfWork.CompleteAsync();
return(new MusicianResponse(existingPerformer));
}
catch (Exception ex)
{
return(new MusicianResponse($"An error has ocurred while updating musician: {ex.Message}"));
}
}
private async void OnSignUp(object obj)
{
try
{
var authService = DependencyService.Resolve <IAuthenticationService>();
Username = $"{Firstname} {Surname}";
if (await authService.CreateUser(Username, Email, Password))
{
var musician = new Musician
{
Id = authService.GetCurrentUserId(),
Firstname = Firstname,
Lastname = Surname,
Email = Email,
BirthDay = null,
TimeStamp = DateTime.Now
};
await App.Database.AddMusician(musician);
await Shell.Current.GoToAsync($"//{nameof(CatalogPage)}");
}
else
{
Console.Write("A problem occurs when creating a user");
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
await Shell.Current.DisplayAlert("Vytvoření uživatele", "Při vytváření uživatele nastala chyba", "OK");
}
}
public ActionResult Create([Bind(Include = "Id, Thumbnail, Name, Instruments, Years, Description")] Musician musician)
{
if (musician.Thumbnail == null)
{
musician.Thumbnail = "http://tinyurl.com/hzeag2q";
}
if (musician.Years == null)
{
musician.Years = "-";
}
if (musician.Description == null)
{
musician.Description = "Biography has not been added to this artist.";
}
if (ModelState.IsValid)
{
_db.Musicians.Add(musician);
_db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(musician));
}
/// <summary>
/// 在游戏即将结束时释放所有资源
/// </summary>
public static void CollapseWorld()
{
Director.IsCollapsing = true;
var collaTimeStamp = DateTime.Now;
LogUtils.LogLine("Yuri world began to collapse at " + collaTimeStamp, "Director", LogLevel.Important);
PersistContextDAO.Assign("___YURIRI@LASTPLAYTIMESTAMP___", collaTimeStamp.ToString());
PersistContextDAO.Assign("___YURIRI@ACCDURATION___", Director.LastGameTimeAcc + (collaTimeStamp - Director.StartupTimeStamp));
PersistContextDAO.SaveToSteadyMemory();
LogUtils.LogLine("Save persistence context OK", "Director", LogLevel.Important);
if (GlobalConfigContext.UseBassEngine == false)
{
MusicianRouterHandler.TerminalFlag = true;
Musician.GetInstance().Dispose();
}
LogUtils.LogLine("Dispose resource OK, program will shutdown soon", "Director", LogLevel.Important);
var ct = DateTime.Now;
GC.Collect();
if (GlobalConfigContext.UseBassEngine == false)
{
while ((DateTime.Now - ct).TotalSeconds < 2 && !MusicianRouterHandler.IsCollapsed)
{
System.Threading.Thread.Sleep(10);
}
}
Environment.Exit(0);
}
public async Task<IActionResult> Edit(int id, [Bind("Id,MusicianName,LastName,FirstName,Bio,Birth,Death,isActive,HomeTown,HomeCountry")] Musician musician)
{
if (id != musician.Id)
{
return NotFound();
}
if (ModelState.IsValid)
{
try
{
_context.Update(musician);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MusicianExists(musician.Id))
{
return NotFound();
}
else
{
throw;
}
}
return RedirectToAction(nameof(Index));
}
return View(musician);
}
private void UpdatePlays(string[] selectedInstruments, Musician musicianToUpdate)
{
if (selectedInstruments == null)
{
musicianToUpdate.Plays = new List <Plays>();
return;
}
var selectedInstrumentsHS = new HashSet <string>(selectedInstruments);
var playsHS = new HashSet <int>(musicianToUpdate.Plays.Select(i => i.InstrumentID));
foreach (var ins in _context.Instruments)
{
if (selectedInstrumentsHS.Contains(ins.ID.ToString()))
{
if (!playsHS.Contains(ins.ID))
{
musicianToUpdate.Plays.Add(new Plays {
MusicianID = musicianToUpdate.ID, InstrumentID = ins.ID
});
}
}
else
{
if (playsHS.Contains(ins.ID))
{
Plays playsToRemove = musicianToUpdate.Plays.SingleOrDefault(i => i.InstrumentID == ins.ID);
_context.Remove(playsToRemove);
}
}
}
}
public Musician AddMusician(AddMusicianRequestDto request)
{
var track = GetOrCreateTrack(request.Track);
var musician = new Musician()
{
FirstName = request.FirstName,
LastName = request.LastName,
NickName = request.NickName
};
_context.Add(musician);
if (track != null)
{
_context.Musician_Track.Add(new MusicianTrack()
{
Musician = musician,
Track = track
});
}
try
{
_context.SaveChanges();
}
catch (Exception e)
{
return(null);
}
return(musician);
}
/// <summary>
/// Adds an instrument to a musician
/// </summary>
/// <param name="Musician"></param>
/// <param name="Instrument"></param>
public static void AddInstrumentToMusician(Musician Musician,
Instrument Instrument)
{
using (var context = new BandBookerContext())
{
var m = (from x in context.Musician
where x.MusicianId == Musician.MusicianId
select x).FirstOrDefault();
var currentMI = (from x in context.MusicianInstrument
where x.MusicianId == Musician.MusicianId &&
x.InstrumentId == Instrument.InstrumentId
select x).FirstOrDefault();
if (currentMI == null)
{
var inst = (from x in context.Instrument
where x.InstrumentId == Instrument.InstrumentId
select x).FirstOrDefault();
var mi = new MusicianInstrument()
{
Musician = m,
Instrument = inst
};
m.MusicianInstrument.Add(mi);
context.SaveChanges();
}
}
}
public async Task <IActionResult> Edit(int id, [Bind("Id,FirstName,LastName,BirthDate,BirthPlace,Photo,ImageType")] Musician musician)
{
if (id != musician.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(musician);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MusicianExists(musician.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(musician));
}
/// <summary>
/// Get all the bookings that this musician has responded to
/// </summary>
/// <param name="Musician"></param>
/// <returns></returns>
public static List <Booking> GetAllBookingsByMusician(Musician Musician)
{
var list = new List <Booking>();
using (var context = new BandBookerContext())
{
// find all the bands this musician belongs to
var bands = from x in BandMusicians
where x.MusicianId == Musician.MusicianId
select x.Band;
foreach (var band in bands)
{
// find all bookings for this band
var bookings = from x in Bookings
where x.BandId == band.BandId
select x;
foreach (var booking in bookings)
{
list.Add(booking);
}
}
}
return(list);
}
public async Task <IActionResult> Login(LoginModel vm)
{
if (ModelState.IsValid)
{
Musician user =
await userManager.FindByNameAsync(vm.UserName);
if (user != null)
{
await signInManager.SignOutAsync();
Microsoft.AspNetCore.Identity.SignInResult result =
await signInManager.PasswordSignInAsync(
user, vm.Password, false, false);
if (result.Succeeded)
{
return(RedirectToAction("Index", "Home"));
}
}
ModelState.AddModelError("", "Invalid name or password");
}
return(View(vm));
}
public void AddMusicianWithTrack(Musician musician)
{
_dbContext.Database.BeginTransaction();
var dbMusician = _dbContext.Musicians.FirstOrDefault(m =>
m.FirstName == musician.FirstName &&
m.LastName == musician.LastName &&
m.Nickname == musician.Nickname
);
if (dbMusician != default)
{
throw new ConflictException("Musician already exists");
}
foreach (var mt in musician.MusicianTracks)
{
var track = mt.Track;
mt.Track = _dbContext.Tracks.FirstOrDefault(t =>
t.TrackName == track.TrackName && Math.Abs(t.Duration - track.Duration) < 0.01f
) ?? track;
}
_dbContext.Musicians.Add(musician);
_dbContext.SaveChanges();
_dbContext.Database.CommitTransaction();
}
public ActionResult Login()
{
string user_name = Request.Form["username"];
if (user_name.Trim() == "")
{
return(Redirect("/"));
}
using (var db = new Models.ApplicationDbContext())
{
Musician user = db.Musicians.FirstOrDefault(m => m.name == user_name);
if (user == null)
{
user = new Musician {
name = user_name
};
db.Musicians.Add(user);
db.SaveChanges();
}
Session["user"] = user;
}
return(Redirect("/chat"));
}
