public SleepingBarber()
{
syncObj = new object();
cq = new Queue <int>();
c = new Customer(syncObj, cq);
b = new Barber(syncObj, cq);
}
public async Task <IActionResult> Put(Barber barber)
{
await this.BarberService.PutBarber(barber);
Console.Out.WriteLine(barber);
return(RedirectToAction("List"));
}
public async Task <ApiResponse <int> > BarberTotalNumberOfHandledCustomer(int BarberId)
{
ApiResponse <int> result = new ApiResponse <int>();
try
{
Barber barber = await unitOfWork.BarbersManager.GetByIdAsync(BarberId);
if (barber != null)
{
result.Data = (int)barber.NumberOfCustomersHandled;
result.Succeeded = true;
return(result);
}
result.Succeeded = false;
result.Errors.Add("It May Be A New Barber !");
result.ErrorType = ErrorType.LogicalError;
return(result);
}
catch (Exception ex)
{
result.Succeeded = false;
result.Errors.Add(ex.Message);
return(result);
}
}
public async Task <ActionResult <Barber> > PostBarber(Barber barber)
{
_context.Barbers.Add(barber);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetBarber", new { id = barber.BarberID }, barber));
}
public IActionResult Index()
{
Barber Aurimas = new Barber()
{
Name = "Aurimas", Surname = "Bajo"
};
Barber Tomas = new Barber()
{
Name = "Tomas", Surname = "Sinickis"
};
List <Booking> bookings = new List <Booking>()
{
new Booking()
{
Barber = Aurimas, BookingStatus = BookingStatus.available, AvailableTime = DateTime.Now
}, //duomenys booking liste, kad prie ju prieit reikia listo tipa perduot i view
new Booking()
{
Barber = Tomas, BookingStatus = BookingStatus.available, AvailableTime = DateTime.Now
},
new Booking()
{
Barber = Aurimas, BookingStatus = BookingStatus.available, AvailableTime = DateTime.Now.AddDays(-1)
},
};
return(View(bookings)); //grazins bookings duomenis, leis juos panaduot
}
public async Task <IActionResult> Edit(int id, [Bind("BarberId,FirstName,LastName,BarberAddress,Zip")] Barber barber)
{
if (id != barber.BarberId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(barber);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BarberExists(barber.BarberId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(barber));
}
void OnTriggerEnter2D(Collider2D other)
{
if (!this.name.Equals("barberChair"))
{
Debug.Log("Char Triggered: " + other.name + " entered in the " + this.name);
GameObject customer = (GameObject)other.gameObject;
this.occupyChair(customer);
//TODO: reference bug here...sometimes we cant reach this script
barberScript = GameObject.Find("Barber").GetComponent <Barber>();
// awake the barber if he is sleeping
if (barberScript)
{
if (!barberScript.isAwake())
{
barberScript.wakeUp();
}
// else {
// Debug.LogError("barberscript not found!");
// }
}
}
}
public ActionResult Edit([Bind(Include = "Id,Name,Surname,Description, Photo,Email,Tel")] Barber barberI)
{
if (!ModelState.IsValid)
{
return(View(barberI));
}
Barber barberB = _context.Barbers.Find(barberI.Id);
if (barberI.Photo != null)
{
if (!barberI.Photo.IsImage())
{
ModelState.AddModelError("Photo", "Photo type is not valid");
barberI.Image = barberB.Image;
return(View(barberI));
}
RemoveImage("Assets/img", barberB.Image);
barberB.Image = barberI.Photo.SavePhoto("Assets/img", "barbers");
}
barberB.Name = barberI.Name;
barberB.Surname = barberI.Surname;
barberB.Description = barberI.Description;
barberB.Email = barberI.Email;
barberB.Tel = barberI.Tel;
_context.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Edit(string id, [Bind("BarberId,FirstName,LastName,Address,Zip,PhoneNumber,BusinessHours,PolicyInfo")] Barber barber)
{
if (id != barber.BarberId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
dbContext.Update(barber);
await dbContext.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BarberExists(barber.BarberId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(barber));
}
public async Task <IActionResult> PutBarber(int id, Barber barber)
{
if (id != barber.BarberID)
{
return(BadRequest());
}
_context.Entry(barber).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BarberExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public JObject UpdateLogInCode([FromBody] Barber barber)
{
JObject responseObj = new JObject();
UserController userController = new UserController();
SqlConnection conn = null;
SqlCommand comm;
String connectionString = ConfigurationManager.ConnectionStrings["azure"].ConnectionString;
Guid g;
g = Guid.NewGuid();
Debug.Write(g);
string logInCode = g.ToString().Split("-")[0].Substring(0, 5);
String query = "Update barber SET login_code = '" + logInCode + "' WHERE barber_id = '" + barber.id + "'";
String emailMessage = "Hi " + barber.username + "," + "<br> <br>" + "Below is your new log-in code that you will need " +
"to enter to access the BarbAR app. <br> <br> This code can be reset at anytime from the log-in page of the app." +
"<br> <br>" + " Log-in Code: <b>" + logInCode + "</b> <br> <br> Thank You, <br> BarbAR Team.";
String subject = "Barber Log-in Code";
try
{
conn = new SqlConnection(connectionString);
conn.Open();
Debug.Write("CONNECTION SUCCESSFUL ");
}
catch (Exception e)
{
Debug.Write("FAILED TO CONNECT: " + e);
}
try
{
comm = new SqlCommand(query, conn);
comm.ExecuteNonQuery();
Debug.Write("UPDATE LOGIN CODE SUCESSFUL ");
responseObj.Add("message", "success");
responseObj.Add("data", barber.toJson());
userController.SendEmail(barber.username, barber.email, logInCode, emailMessage, subject);
conn.Close();
Debug.Write("CONNECTION CLOSED ");
}
catch (Exception e)
{
Debug.Write("FAILED TO UPDATE: " + e);
responseObj.Add("message", "failed");
responseObj.Add("data", barber.toJson());
responseObj.Add("error", e.GetBaseException().ToString());
}
return(responseObj);
}
public async Task <Barber> RegisterBarber(Barber barber, string password)
{
// Validation
if (string.IsNullOrWhiteSpace(password))
{
throw new AppException("Password is required");
}
if (_context.Barbers.Any(usr => usr.Username == barber.Username))
{
throw new AppException("Username \"" + barber.Username + "\" is already taken");
}
byte[] passwordHash, passwordSalt;
CreatePasswordHash(password, out passwordHash, out passwordSalt);
barber.PasswordHash = passwordHash;
barber.PasswordSalt = passwordSalt;
await _context.Barbers.AddAsync(barber);
await _context.SaveChangesAsync();
return(barber);
}
public async Task <IHttpActionResult> PutBarber(int id, Barber barber)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != barber.BarberId)
{
return(BadRequest());
}
db.Entry(barber).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BarberExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public Barber Create(Barber model)
{
_ctx.Barbers.Add(model);
_ctx.SaveChanges();
return(model);
}
public ArrayList Get()
{
ArrayList barbers = new ArrayList();
SqlConnection conn = null;
SqlCommand comm;
SqlDataReader reader = null;
String connectionString = ConfigurationManager.ConnectionStrings["azure"].ConnectionString;
String query = "SELECT * FROM barber;";
try
{
conn = new SqlConnection(connectionString);
conn.Open();
Debug.Write("CONNECTION SUCCESSFUL ");
conn = new SqlConnection(connectionString);
conn.Open();
Debug.Write("CONNECTION SUCCESSFUL");
}
catch (Exception e)
{
Debug.Write("FAILED TO CONNECT: " + e);
}
try
{
comm = new SqlCommand(query, conn);
comm.ExecuteNonQuery();
reader = comm.ExecuteReader();
while (reader.Read())
{
Barber barber = new Barber();
barber.id = reader.GetInt32(0);
barber.username = reader.GetString(1);
barber.firstname = reader.GetString(2);
barber.surname = reader.GetString(3);
barber.email = reader.GetString(4);
barber.password = reader.GetString(5);
barber.avatar = reader.GetString(6);
barber.login_code = reader.GetString(7);
barbers.Add(barber);
}
Debug.Write("INSERT SUCCESSFUL");
conn.Close();
Debug.Write("CONNECTION CLOSED");
}
catch (Exception e)
{
Debug.Write("FAILED TO INSERT: " + e);
}
return(barbers);
}
public IActionResult DeleteConfirmed(int id)
{
Barber barber = _context.Barbers.Single(m => m.BarberId == id);
_context.Barbers.Remove(barber);
_context.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task SendNewSalonBarberEmailAsync(BeautySalon salon, Barber barber)
{
var template = await emailTemplatesManager.ReadTemplateAsync(emailTemplateSettings.NewEntity.TemplateName);
template = emailTemplateParser.PrepareNewSalonBarberEmail(salon, barber, template);
var subject = ParseSubjectId(emailTemplateSettings.NewEntity.Subject, barber.BarberId.ToString());
await emailManager.SendAsync(barber.Email, barber.BarberName, subject, template);
}
void Start()
{
barbershopScript = GameObject.Find("MainController").GetComponent <BarberShop>();
barberChairScript = GameObject.Find("barberChair").GetComponent <Chair>();
barberScript = this.GetComponent <Barber>();
toggleAwake = GameObject.Find("ToggleAwake").GetComponent <Toggle>();
sleep();
}
// Task 4: Sleeping Barber
public static void RunTask4(int maxClientsCount)
{
var barberShop = new BarberShop(maxClientsCount);
var barber = new Barber(barberShop);
var client = new Client(barberShop);
Task.WaitAll(barber.Run(), client.Run());
}
public ActionResult DeleteConfirmed(int id)
{
Barber barber = db.Barbers.Find(id);
db.Barbers.Remove(barber);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Edit([Bind(Include = "BarberID,Name,PhotoFile,About")] Barber barber, HttpPostedFileBase image, string sun, string mon, string tue, string wed, string thur, string fri, string sat)
{
List <string> Days = new List <string>();
if (ModelState.IsValid)
{
if (image != null)
{
barber.ImageMimeType = image.ContentType;
barber.PhotoFile = new byte[image.ContentLength];
image.InputStream.Read(barber.PhotoFile, 0, image.ContentLength);
}
if (sun != null)
{
Days.Add(sun);
}
if (mon != null)
{
Days.Add(mon);
}
if (tue != null)
{
Days.Add(tue);
}
if (wed != null)
{
Days.Add(wed);
}
if (thur != null)
{
Days.Add(thur);
}
if (fri != null)
{
Days.Add(fri);
}
if (sat != null)
{
Days.Add(sat);
}
var DDays = db.Days.Where(x => x.Barber.BarberID == barber.BarberID);
foreach (var item in DDays)
{
db.Days.Remove(item);
}
foreach (var day in Days)
{
db.Days.Add(new Day {
Barber = barber, day = day
});
}
db.Entry(barber).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(barber));
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
Barber barber = await db.Barbers.FindAsync(id);
db.Barbers.Remove(barber);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
// GET: Barber
public ActionResult Random()
{
var barber = new Barber()
{
FirstName = "Cornell!"
};
return(View(barber));
}
public void Awake()
{
barber = GameObject.Find("Barber");
// if(!barber) Debug.LogError("Barber GameObject not found!");
barberScript = barber.GetComponent <Barber>();
//barberScript = GameObject.Find("Barber").GetComponent<Barber>();
// Debug.LogError("Chair.cs: barberscript not found!");
}
public ActionResult Edit([Bind(Include = "id,Name,ImagenUrl,Description,Horary,Phone")] Barber barber)
{
if (ModelState.IsValid)
{
db.Entry(barber).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(barber));
}
public IActionResult Edit(Barber barber)
{
if (ModelState.IsValid)
{
_context.Update(barber);
_context.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(barber));
}
public int CompareTo(object obj)
{
Barber bObj = (Barber)obj;
if (bObj.readyTime != this.readyTime)
{
return(this.readyTime.CompareTo(bObj.readyTime));
}
return(this.idx.CompareTo(bObj.idx));
}
/// <summary>
/// Set up the database with some example data
/// </summary>
/// <param name="context">the barbershop database context</param>
protected override void Seed(BarberShopContext context)
{
var joe = new Barber {
Name = "Joe"
};
var gary = new Barber {
Name = "Gary"
};
var barbers = new List <Barber> {
joe, gary
};
barbers.ForEach(b => context.Barbers.Add(b));
context.SaveChanges();
var customers = new List <Customer>
{
new Customer {
FirstName = "Donald", LastName = "Duck",
PhoneNumber = "8605551212",
ArrivalTime = DateTime.Parse("2020-2-26 4:00PM")
},
new Customer {
FirstName = "Mickey", LastName = "Mouse",
PhoneNumber = "7165551212",
ArrivalTime = DateTime.Parse("2020-2-26 4:01PM")
},
new Customer {
FirstName = "Ilove", LastName = "Joe",
PhoneNumber = "2125551212",
ArrivalTime = DateTime.Parse("2020-2-26 4:02PM"),
PreferredBarber = joe
},
new Customer {
FirstName = "Mister", LastName = "Jones",
PhoneNumber = "6125551212",
ArrivalTime = DateTime.Parse("2020-2-26 4:08PM"),
},
new Customer {
FirstName = "Wile", LastName = "Coyote",
PhoneNumber = "3135551212",
ArrivalTime = DateTime.Parse("2020-2-26 4:10PM"),
},
new Customer {
FirstName = "Ilove", LastName = "Gary",
PhoneNumber = "8005551212",
ArrivalTime = DateTime.Parse("2020-2-26 4:02PM"),
PreferredBarber = gary
},
};
customers.ForEach(c => context.Customers.Add(c));
context.SaveChanges();
}
public string PrepareNewSalonBarberEmail(BeautySalon salon, Barber barber, string stringTemplate)
{
var url = $"{clientSettings.Url}activate";
var today = DateTime.Today.ToString("d", CultureInfo.InvariantCulture);
stringTemplate = stringTemplate.Replace("{{{url}}}", url);
stringTemplate = stringTemplate.Replace("{{{salon}}}", salon.SalonName);
stringTemplate = stringTemplate.Replace("{{{barber}}}", barber.BarberName);
stringTemplate = stringTemplate.Replace("{{{today}}}", today);
return(stringTemplate);
}
public async Task <IActionResult> Create([Bind("BarberId,FirstName,LastName,BarberAddress,Zip")] Barber barber)
{
if (ModelState.IsValid)
{
_context.Add(barber);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(barber));
}
