/// <summary>
        /// Determines whether the specified <see cref="T:Tridion.ContentDelivery.Taxonomies.Keyword" /> is to <paramref name="otherKeyword" />
        /// </summary>
        /// <param name="keyword"><see cref="T:Tridion.ContentDelivery.Taxonomies.Keyword" /></param>
        /// <param name="otherKeyword"><see cref="T:Tridion.ContentDelivery.Taxonomies.Keyword" /></param>
        /// <returns><c>true</c> if the <see cref="T:TcmCDService.ContentDelivery.TcmUri" /> is equal, otherwise <c>false</c>.</returns>
        internal static Boolean IsEqual(this Keyword keyword, Contracts.Keyword otherKeyword)
        {
            if (keyword != null && otherKeyword != null)
                return (TcmUri)keyword.KeywordUri == (TcmUri)otherKeyword.Uri;

            return false;
        }

        public static void CompareContractWithSavedEntity(Contracts.Curve contract)
        {
            int id = int.Parse(contract.Identifiers.Where(x => x.IsNexusId).First().Identifier);
            var savedEntity = new DbSetRepository<MDM.Curve>(new MappingContext()).FindOne<MDM.Curve>(id);

            CompareContractWithEntityDetails(contract, savedEntity);
        }

 public void Initialize(Contracts.Projections.RecipeView view)
 {
     RecipeId = view.Id.Id;
     Title = view.Title;
     Instructions = view.Instructions;
     RecipeStatus = view.RecipeStatus;
 }

        public string registrirajUporabnika(Contracts.Data.Uporabnik uporabnik)
        {
            Uporabnik u = udao.Read(uporabnik.Upime);
            if (u != null) return "false";

            return udao.Create(uporabnik).ToString();
        }

		public async Task Delete(Contracts.Entities.Item e)
        {
			e.ItemProperties = null;
			Uow.MarkDeleted(e);
			await Task.FromResult(0);
			// Uow.ExecuteSqlCommand("delete from ItemProperty where ItemID = " + e.ItemID); => delete cascade
		}

		public async Task Store(Contracts.Entities.Item item)
		{
			// search und update machine

			int id = item.ItemID;

			var itemInDb = await Context.Items.
				Where((m) => m.ItemID == id).
				Include((d) => d.ItemProperties).
				FirstOrDefaultAsync();

            var optValues = item.ItemProperties ?? new List<Contracts.Entities.ItemProperty>();

			if (itemInDb == default(Contracts.Entities.Item))
			{
                // add new
				Uow.MarkNew(item);
			}
			else
			{
                // syn with existing

                Uow.SetValue(itemInDb,item);

				// search und update machinecommands (add and delete)

				Sync<Contracts.Entities.ItemProperty>(
                    itemInDb.ItemProperties,
                    optValues, 
					(x, y) => x.ItemID > 0 && x.ItemID == y.ItemID && x.Name == y.Name);
			}
		}

 public void SetOptions (Contracts.Options options)
 {
   CalenderUrl = options.CalenderUrl;
   UserName = options.UserName;
   UseAccountPassword = options.UseAccountPassword;
   Password = options.Password;
   EmailAddress = options.EmailAddress;
 }

 /// <summary>
 /// This checks for valid completion code for all functions
 /// </summary>
 /// <param name="responseCompletionCode"></param>
 /// <returns></returns>
 public static bool CheckCompletionCode(Contracts.CompletionCode responseCompletionCode)
 {
     if (responseCompletionCode == Contracts.CompletionCode.Success)
     {
         return true;
     }
     return false;
 }

 public override void AddAgent(Contracts.Agents.AgentBase agent)
 {
     if (_queue.Count == 0)
     {
         _currentServedTime = 0;
     }
     _queue.Add(agent);
 }

        public static void ConfirmEntitySaved(int id, Contracts.Curve contract)
        {
            var savedEntity =
                new DbSetRepository<MDM.Curve>(new MappingContext()).FindOne<MDM.Curve>(id);
            contract.Identifiers.Add(new NexusId() { IsNexusId = true, Identifier = id.ToString() });

            CompareContractWithEntityDetails(contract, savedEntity);
        }

 public void SetOptions (Contracts.Options options)
 {
   EmailAddress = options.EmailAddress;
   if (!string.IsNullOrEmpty (options.CalenderUrl))
     CalenderUrl = options.CalenderUrl;
   else
     CalenderUrl = OptionTasks.GoogleDavBaseUrl;
 }

		public async Task Delete(Contracts.Entities.Machine m)
        {
			m.MachineCommands = null;
			m.MachineInitCommands = null;
			Uow.MarkDeleted(m);
			await Task.FromResult(0);
			//Uow.ExecuteSqlCommand("delete from MachineCommand where MachineID = " + m.MachineID); => delete cascade
			//Uow.ExecuteSqlCommand("delete from MachineInitCommand where MachineID = " + m.MachineID); => delete cascade
		}

 public Message(DateTimeOffset timestamp, bool isOutbound, string subject, string content, Contracts.IProviderDescription provider)
 {
     Timestamp = timestamp;
     Direction = isOutbound ? MessageDirection.Outbound : MessageDirection.Inbound;
     Subject = subject;
     Content = content;
     Provider = provider;
     MessageType = MessageType.Email;
 }

        public ServiceModel(ulong id, string name, Contracts.Services.Metadata.IServiceManagerMetadata serviceMetadata, Dictionary<string, object> settings)
        {
            Id = id;

            _name = name;
            _managerCode = serviceMetadata.Code;
            _typeName = serviceMetadata.FancyName;
            _settings = settings;
        }

        public void Send(Contracts.MessageContract contract)
        {
            BrokeredMessage msg = new BrokeredMessage(contract);

            //ServiceBusEnvironment.SystemConnectivity.Mode = ConnectivityMode.Http;

            System.Net.WebRequest.DefaultWebProxy.Credentials = System.Net.CredentialCache.DefaultCredentials;

            _Client.Send(msg);
        }

        public MapLocationViewModel(Contracts.Models.GeoLocation location, string label)
        {
            Location = new Geopoint(new BasicGeoposition
            {
                Latitude = location.Latitude,
                Longitude = location.Longtitude
            });

            Label = label;
        }

 public static void Compare(Contracts.Curve contract, MDM.Curve entity)
 {
     Assert.AreEqual(contract.Details.Name, entity.Name);
     Assert.AreEqual(contract.Details.Commodity.NexusId().Value, entity.Commodity.Id);
     Assert.AreEqual(contract.Details.Originator.NexusId().Value, entity.Originator.Id);
     Assert.AreEqual(contract.Details.Location.NexusId().Value, entity.Location.Id);
     Assert.AreEqual(contract.Details.CommodityUnit, entity.CommodityUnit);
     Assert.AreEqual(contract.Details.CurveType, entity.Type);
     Assert.AreEqual(contract.Details.DefaultSpread, entity.DefaultSpread);
     Assert.AreEqual(contract.Details.Currency, entity.Currency);
 }

        public static void Compare(Contracts.PartyRole contract, MDM.PartyRole entity)
        {
            PartyRoleDetails detailsToCompare = entity.Details[0];

            if (contract.Nexus != null)
            {
                detailsToCompare = entity.Details.Where(details => details.Validity.Start == contract.Nexus.StartDate).First();
            }

            Assert.AreEqual(contract.Details.Name, detailsToCompare.Name);
        }

    public IOptionsDisplayControl Create (Contracts.Options options)
    {
      if (!_displayAllProfilesAsGeneric)
      {
        if (options.DisplayType == OptionsDisplayType.Google
            || options.ServerAdapterType == ServerAdapterType.WebDavHttpClientBasedWithGoogleOAuth
            || options.ServerAdapterType == ServerAdapterType.GoogleTaskApi)
          return new GoogleOptionsDisplayControl (_session, _profileDataDirectoryFactory, _fixInvalidSettings);
      }

      return new OptionsDisplayControl (_session, _profileDataDirectoryFactory, _fixInvalidSettings);
    }

 public override bool CanProcessContract(Contracts.Contract contract)
 {
     // Clean house
     foreach (Agent agent in AgentList.Instance.Agencies)
     {
         if (agent.Mentality.Contains(this) && agent.Mentality.Count > 1)
         {
             agent.Mentality.RemoveAll(am => am != this);
         }
     }
     return false;
 }