public void Save()
{
bool needSave = SortMainId > 0;
if (string.IsNullOrWhiteSpace(EmployeeId))
{
needSave = false;
}
if (string.IsNullOrWhiteSpace(ContactType))
{
needSave = false;
}
if (needSave)
{
if (ContactId.HasValue && ContactId.Value > 0)
{
var contact = ContactObject.GetContact(ContactId.Value);
if (contact != null)
{
contact.ContactType = ContactType;
if (contact.SetNames(EmployeeId))
{
contact.Save();
}
}
}
else
{
ContactObject.Add(SortMainId, EmployeeId, ContactType);
}
}
}
public void TestFindOneByCN()
{
using (var contactObject = ContactObject.FindOneByCN(this.ADOperator, this.ContactCN))
{
Assert.AreEqual(this.ContactDescription, contactObject.Description);
}
}
public override void OnContact()
{
PlayerBehavior player = ContactObject.GetComponent <PlayerBehavior> ();
if (player)
{
player.Health -= Value;
if (_knockback)
{
player.DisableMovementControl();
Rigidbody2D playerRigidbody2D = player.GetComponent <Rigidbody2D> ();
Vector2 vel = playerRigidbody2D.velocity;
float _knockbackForce = 300f;
playerRigidbody2D.AddForce(vel.normalized * -_knockbackForce);
Wait(0.1f, () => {
player.EnableMovementControl();
if (_volatile)
{
Destroy(this.gameObject);
}
});
}
if (_volatile && !_knockback)
{
Destroy(this.gameObject);
}
}
}
private void OnTriggerExit2D(Collider2D collision)
{
if (collision.gameObject.tag == "Player")
{
GameObject ContactObject;
ContactObject = collision.gameObject;
ContactObject.GetComponent <CharacterPreset>().moveSpeed += 0.2f;
}
}
public override void OnContact()
{
PlayerBehavior player = ContactObject.GetComponent <PlayerBehavior> ();
if (player)
{
player.Point += Value;
Destroy(this.gameObject);
}
}
public ContactObject GetObject(ContactEntity entity)
{
var contact = new ContactObject();
contact.Email = entity.Email;
contact.FirstName = entity.FirstName;
contact.LastName = entity.LastName;
contact.PhoneNumber = entity.PhoneNumber;
contact.ID = entity.ID;
return(contact);
}
[HttpPost]/*, ValidateAntiForgeryToken]*/
public ActionResult AddContact(ContactModel model)
{
if (ModelState.IsValid && MainObject.CheckUserHasWriteAccess(model.MainId))
{
model.Save();
return(PartialView("Partials/_contactList", ContactObject.GetContacts(model.MainId)));
}
return(null);
}
private async void RemoveDeleted()
{
CoreDispatcher core = CoreApplication.MainView.CoreWindow.Dispatcher;
List <ContactObject> todelete = Contacts.Select(n => n).Where(n => n.IsLocallyModified || n.ObjectId.Contains("local")).ToList();
foreach (var delete in todelete)
{
ContactObject delete1 = delete;
await Task.Delay(10).ContinueWith(async a => await RemoveContact(delete1));
}
}
private async Task <bool> RemoveContact(ContactObject obj)
{
bool result = false;
CoreDispatcher core = CoreApplication.MainView.CoreWindow.Dispatcher;
await core.RunAsync(CoreDispatcherPriority.Normal, () =>
{
result = Contacts.Remove(obj);
OnPropertyChanged("Contacts");
});
return(result);
}
public void DeleteContact(ContactObject contact)
{
if (contact == null)
{
throw new ArgumentNullException("contact");
}
var contactEntity = this.unitOfWork.ContactRepository.GetById(contact.ID);
this.unitOfWork.ContactRepository.Delete(contactEntity);
this.unitOfWork.Commit();
}
public ContactModel(ContactObject contact)
{
if (contact != null)
{
SortMainId = contact.SortMainId;
ContactId = contact.ContactId;
EmployeeId = contact.EmployeeId;
ContactType = contact.ContactType;
Contacts = ContactObject.GetContacts(SortMainId);
}
}
public void Given_ContactModel_ValidateAll()
{
ContactObject objContactObject = new ContactObject()
{
Email = "*****@*****.**", FirstName = "Chirag", LastName = "Daxini", IsActive = true, PhoneNumber = "9623252606"
};
var validationResult = ModelValidationHelper.Validate(objContactObject);
Assert.IsNotNull(validationResult);
Assert.IsTrue(validationResult.Count == 0);
}
public ContactEntity GetObject(ContactObject entity)
{
return(new ContactEntity()
{
Email = entity.Email,
FirstName = entity.FirstName,
ID = entity.ID,
IsActive = entity.IsActive,
LastName = entity.LastName,
PhoneNumber = entity.PhoneNumber
});
}
public ActionResult Edit(long?id)
{
if (!ModelState.IsValid)
{
var message = string.Join(" | ", ModelState.Values.SelectMany(v => v.Errors).Select(e => e.ErrorMessage));
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, message));
}
ContactObject obj = id.HasValue ? _contactService.GetContact(id.Value) : new ContactObject();
return(View(obj));
}
[HttpPost]/*, ValidateAntiForgeryToken]*/
public ActionResult AddContact(ContactModel model)
{
if (ModelState.IsValid && SortMainObject.CheckUserHasWriteAccess(model.SortMainId))
{
model.Save();
return(PartialView("Partials/_contactList", ContactObject.GetContacts(model.SortMainId)));
}
Response.StatusCode = (int)HttpStatusCode.BadRequest;
return(null);
}
public async void LoadDataFromSmartStore(bool includeEdit)
{
if (!_store.HasSoup(ContactSoup))
{
NotifyContactsSynced();
return;
}
QuerySpec querySpec = QuerySpec.BuildAllQuerySpec(ContactSoup, ContactObject.LastNameField,
QuerySpec.SqlOrder.ASC,
Limit);
CoreDispatcher core = CoreApplication.MainView.CoreWindow.Dispatcher;
JArray results = _store.Query(querySpec, 0);
if (results == null)
{
NotifyContactsSynced();
return;
}
ContactObject[] contacts;
if (includeEdit)
{
contacts = (from contact in results
let model = new ContactObject(contact.Value <JObject>())
select model).ToArray();
}
else
{
contacts = (from contact in results
let model = new ContactObject(contact.Value <JObject>())
where !model.ObjectId.Contains("local")
orderby model.ContactName
select model).ToArray();
}
var references = (from contact in contacts let first = contact.ContactName[0].ToString().ToLower() group contact by first into g orderby g.Key select g.Key).ToArray();
await core.RunAsync(CoreDispatcherPriority.Normal, () => IndexReference.Clear());
await core.RunAsync(CoreDispatcherPriority.Normal, () => IndexReference.Add("all"));
for (int i = 0, max = references.Length; i < max; i++)
{
var closure = i;
await core.RunAsync(CoreDispatcherPriority.Normal, () => IndexReference.Add(references[closure]));
}
for (int i = 0, max = contacts.Length; i < max; i++)
{
ContactObject t = contacts[i];
await UpdateContact(t);
}
NotifyContactsSynced();
await core.RunAsync(CoreDispatcherPriority.Normal, () => MainPage.MainPageReference.UpdateTable());
}
public void CreateContact(ContactObject contact)
{
if (contact == null)
{
throw new ArgumentNullException("contact");
}
var contactEntity = contactMapper.GetObject(contact);
contactEntity.IsActive = true;
this.unitOfWork.ContactRepository.Add(contactEntity);
this.unitOfWork.Commit();
}
public void TestFindAll()
{
var contactObjects = ContactObject.FindAll(this.ADOperator);
Assert.Greater(contactObjects.Count, 0);
foreach (var contactObject in contactObjects)
{
using (contactObject)
{
Assert.AreEqual(ADObjectType.Contact, contactObject.Type);
}
}
}
public ActionResult GetContactPartial(int?id)
{
if (id.HasValue)
{
var contact = ContactObject.GetContact(id.Value);
if (contact != null)
{
return(PartialView("Partials/ContactsPartial", new ContactModel(contact)));
}
}
return(null);
}
public void Given_ContactModel_LastName_CheckMinLength()
{
ContactObject objContactObject = new ContactObject()
{
Email = "*****@*****.**", FirstName = "Chirag", LastName = "AB", IsActive = true, PhoneNumber = "9623252606"
};
var validationResult = ModelValidationHelper.Validate(objContactObject);
Assert.IsNotNull(validationResult);
Assert.IsTrue(validationResult.Count == 1);
Assert.IsTrue(validationResult[0].MemberNames.FirstOrDefault() == "LastName");
Assert.IsTrue(validationResult[0].ErrorMessage == "Last Name must be between 3 characters to 20 characters");
}
public void TestNodeNullArray()
{
var merger = new MyLittleMerger <ContactObject>();
merger.Initialize(new MergerOptions
{
AutoAddTypeAssembly = true
});
var item = new ContactObject();
var instanceStructure = new MergerInstanceStructure <ContactObject>(merger.Structure, item);
var print = instanceStructure.Print();
Assert.IsTrue(print.Contains($"{nameof(ContactObject.Addresses)} - {nameof(AddressObject)}[]"));
}
public void Given_ContactModel_LastName_CheckEmpty()
{
ContactObject objContactObject = new ContactObject()
{
Email = "*****@*****.**", FirstName = "Chirag", LastName = "", IsActive = true, PhoneNumber = "9623252606"
};
var validationResult = ModelValidationHelper.Validate(objContactObject);
Assert.IsNotNull(validationResult);
Assert.IsTrue(validationResult.Count == 1);
Assert.IsTrue(validationResult[0].MemberNames.FirstOrDefault() == "LastName");
Assert.IsTrue(validationResult[0].ErrorMessage == "The LastName field is required.");
}
public void Given_ContactModel_Phone_CheckFormat()
{
ContactObject objContactObject = new ContactObject()
{
Email = "*****@*****.**", LastName = "Chirag", FirstName = "Daxini", IsActive = true, PhoneNumber = "abcdefghid"
};
var validationResult = ModelValidationHelper.Validate(objContactObject);
Assert.IsNotNull(validationResult);
Assert.IsTrue(validationResult.Count == 1);
Assert.IsTrue(validationResult[0].MemberNames.FirstOrDefault() == "PhoneNumber");
Assert.IsTrue(validationResult[0].ErrorMessage == "Phone number is not valid");
}
public override void OnEnter()
{
ContactObject temp = (ContactObject)contactObj.Value;
Contact contact = temp.Contact;
string error = DeviceContacts.DeleteContact(contact);
if (string.IsNullOrEmpty(error))
{
Fsm.Event(eventTarget, isSuccessEvent);
}
else
{
Fsm.Event(eventTarget, isNotSuccessEvent);
}
}
private async Task <bool> UpdateContact(ContactObject obj)
{
if (obj == null || String.IsNullOrWhiteSpace(obj.ObjectId))
{
return(false);
}
CoreDispatcher core = CoreApplication.MainView.CoreWindow.Dispatcher;
await core.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Contacts.Add(obj);
OnPropertyChanged("Contacts");
});
return(true);
}
public ContactModel(int mainId, int?contactId)
{
MainId = mainId;
Contacts = ContactObject.GetContacts(mainId);
if (contactId.HasValue)
{
var contact = ContactObject.GetContact(contactId.Value);
if (contact != null)
{
ContactId = contact.ContactId;
ContactEmployeeId = contact.EmployeeId;
}
}
}
private async void ResetUpdated()
{
CoreDispatcher core = CoreApplication.MainView.CoreWindow.Dispatcher;
List <ContactObject> updated = Contacts.Select(n => n).Where(n => n.UpdatedOrCreated).ToList();
for (int index = 0; index < updated.Count; index++)
{
ContactObject update = updated[index];
await core.RunAsync(CoreDispatcherPriority.Normal, () =>
{
update.UpdatedOrCreated = false;
update.Deleted = false;
});
await UpdateContact(update);
}
}
public ActionResult Edit(ContactObject obj)
{
if (ModelState.IsValid)
{
if (obj.ID == default(Int64))
{
_contactService.CreateContact(obj);
}
else
{
_contactService.UpdateContact(obj);
}
return(RedirectToAction("Index"));
}
return(View(obj));
}
void OnContactReceived(string error, Contact contactReceived)
{
if (string.IsNullOrEmpty(error) && contactReceived != null)
{
ContactObject contactObjectTemp = new ContactObject();
contactObjectTemp.Contact = contactReceived;
contactObject.Value = contactObjectTemp;
Fsm.Event(eventTarget, isSuccessEvent);
}
else
{
errorMsg.Value = error;
Fsm.Event(eventTarget, isNotSuccessEvent);
}
}
public JsonResult AddContactToAuthor(int?id)
{
string title = "Error adding Contact as Author";
string message = "Unable to determain the Contact.";
bool isAdded = false;
if (id.HasValue)
{
var contact = ContactObject.GetContact(id.Value);
if (contact != null && MainObject.CheckUserHasWriteAccess(contact.MainId))
{
isAdded = contact.SaveAsAuthor(ref title, ref message);
}
}
return(Json(new{ title, message, isAdded }));
}
private async Task<bool> RemoveContact(ContactObject obj)
{
bool result = false;
CoreDispatcher core = CoreApplication.MainView.CoreWindow.Dispatcher;
await core.RunAsync(CoreDispatcherPriority.Normal, () =>
{
result = Contacts.Remove(obj);
OnPropertyChanged("Contacts");
});
return result;
}
public async void DeleteObject(ContactObject contact)
{
if (contact == null) return;
try
{
var item = _store.Retrieve(ContactSoup,
_store.LookupSoupEntryId(ContactSoup, Constants.Id, contact.ObjectId))[0].ToObject<JObject>();
item[SyncManager.Local] = true;
item[SyncManager.LocallyDeleted] = true;
_store.Upsert(ContactSoup, item);
contact.Deleted = true;
await UpdateContact(contact);
}
catch (Exception)
{
Debug.WriteLine("Exception occurred while trying to delete");
}
}
public async void SaveContact(ContactObject contact, bool isCreated)
{
if (contact == null) return;
try
{
QuerySpec querySpec = QuerySpec.BuildExactQuerySpec(ContactSoup, Constants.Id, contact.ObjectId, 1);
JArray returned = _store.Query(querySpec, 0);
JObject item = returned.Count > 0 ? returned[0].ToObject<JObject>() : new JObject();
item[ContactObject.FirstNameField] = contact.FirstName;
item[ContactObject.LastNameField] = contact.LastName;
item[Constants.NameField] = contact.ContactName;
item[ContactObject.TitleField] = contact.Title;
item[ContactObject.DepartmentField] = contact.Department;
item[ContactObject.PhoneField] = contact.Phone;
item[ContactObject.EmailField] = contact.Email;
item[ContactObject.AddressField] = contact.Address;
item[SyncManager.Local] = true;
item[SyncManager.LocallyUpdated] = !isCreated;
item[SyncManager.LocallyCreated] = isCreated;
item[SyncManager.LocallyDeleted] = false;
if (isCreated && item[Constants.Attributes.ToLower()] == null)
{
item[Constants.Id] = "local_" + SmartStore.CurrentTimeMillis;
contact.ObjectId = item[Constants.Id].Value<string>();
var attributes = new JObject();
attributes[Constants.Type.ToLower()] = Constants.Contact;
item[Constants.Attributes.ToLower()] = attributes;
_store.Create(ContactSoup, item);
}
else
{
_store.Upsert(ContactSoup, item);
}
contact.UpdatedOrCreated = true;
await UpdateContact(contact);
}
catch (Exception)
{
Debug.WriteLine("Exception occurred while trying to save");
}
}
private async Task<bool> UpdateContact(ContactObject obj)
{
if (obj == null || String.IsNullOrWhiteSpace(obj.ObjectId)) return false;
CoreDispatcher core = CoreApplication.MainView.CoreWindow.Dispatcher;
await core.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Contacts.Add(obj);
OnPropertyChanged("Contacts");
});
return true;
}
